Full source code website bán hàng thương mại điện tử gần giống shopee
469.177 lượt xem;
1 /*! jQuery UI - v1.11.4 - 2015-03-11
2 * http://jqueryui.com
3 * Includes: core.js, widget.js, mouse.js, position.js, accordion.js, autocomplete.js, button.js, datepicker.js, dialog.js, draggable.js, droppable.js, effect.js, effect-blind.js, effect-bounce.js, effect-clip.js, effect-drop.js, effect-explode.js, effect-fade.js, effect-fold.js, effect-highlight.js, effect-puff.js, effect-pulsate.js, effect-scale.js, effect-shake.js, effect-size.js, effect-slide.js, effect-transfer.js, menu.js, progressbar.js, resizable.js, selectable.js, selectmenu.js, slider.js, sortable.js, spinner.js, tabs.js, tooltip.js
4 * Copyright 2015 jQuery Foundation and other contributors; Licensed MIT */
5
6 (function( factory ) {
7 if ( typeof define === "function" && define.amd ) {
8
9 // AMD. Register as an anonymous module.
10 define([ "jquery" ], factory );
11 } else {
12
13 // Browser globals
14 factory( jQuery );
15 }
16 }(function( $ ) {
17 /*!
18 * jQuery UI Core 1.11.4
19 * http://jqueryui.com
20 *
21 * Copyright jQuery Foundation and other contributors
22 * Released under the MIT license.
23 * http://jquery.org/license
24 *
25 * http://api.jqueryui.com/category/ui-core/
26 */
27
28
29 // $.ui might exist from components with no dependencies, e.g., $.ui.position
30 $.ui = $.ui || {};
31
32 $.extend( $.ui, {
33 version: "1.11.4",
34
35 keyCode: {
36 BACKSPACE: 8,
37 COMMA: 188,
38 DELETE: 46,
39 DOWN: 40,
40 END: 35,
41 ENTER: 13,
42 ESCAPE: 27,
43 HOME: 36,
44 LEFT: 37,
45 PAGE_DOWN: 34,
46 PAGE_UP: 33,
47 PERIOD: 190,
48 RIGHT: 39,
49 SPACE: 32,
50 TAB: 9,
51 UP: 38
52 }
53 });
54
55 // plugins
56 $.fn.extend({
57 scrollParent: function( includeHidden ) {
58 var position = this.css( "position" ),
59 excludeStaticParent = position === "absolute",
60 overflowRegex = includeHidden ? /(auto|scroll|hidden)/ : /(auto|scroll)/,
61 scrollParent = this.parents().filter( function() {
62 var parent = $( this );
63 if ( excludeStaticParent && parent.css( "position" ) === "static" ) {
64 return false;
65 }
66 return overflowRegex.test( parent.css( "overflow" ) + parent.css( "overflow-y" ) + parent.css( "overflow-x" ) );
67 }).eq( 0 );
68
69 return position === "fixed" || !scrollParent.length ? $( this[ 0 ].ownerDocument || document ) : scrollParent;
70 },
71
72 uniqueId: (function() {
73 var uuid = 0;
74
75 return function() {
76 return this.each(function() {
77 if ( !this.id ) {
78 this.id = "ui-id-" + ( ++uuid );
79 }
80 });
81 };
82 })(),
83
84 removeUniqueId: function() {
85 return this.each(function() {
86 if ( /^ui-id-\d+$/.test( this.id ) ) {
87 $( this ).removeAttr( "id" );
88 }
89 });
90 }
91 });
92
93 // selectors
94 function focusable( element, isTabIndexNotNaN ) {
95 var map, mapName, img,
96 nodeName = element.nodeName.toLowerCase();
97 if ( "area" === nodeName ) {
98 map = element.parentNode;
99 mapName = map.name;
100 if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
101 return false;
102 }
103 img = $( "img[usemap='#" + mapName + "']" )[ 0 ];
104 return !!img && visible( img );
105 }
106 return ( /^(input|select|textarea|button|object)$/.test( nodeName ) ?
107 !element.disabled :
108 "a" === nodeName ?
109 element.href || isTabIndexNotNaN :
110 isTabIndexNotNaN) &&
111 // the element and all of its ancestors must be visible
112 visible( element );
113 }
114
115 function visible( element ) {
116 return $.expr.filters.visible( element ) &&
117 !$( element ).parents().addBack().filter(function() {
118 return $.css( this, "visibility" ) === "hidden";
119 }).length;
120 }
121
122 $.extend( $.expr[ ":" ], {
123 data: $.expr.createPseudo ?
124 $.expr.createPseudo(function( dataName ) {
125 return function( elem ) {
126 return !!$.data( elem, dataName );
127 };
128 }) :
129 // support: jQuery <1.8
130 function( elem, i, match ) {
131 return !!$.data( elem, match[ 3 ] );
132 },
133
134 focusable: function( element ) {
135 return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) );
136 },
137
138 tabbable: function( element ) {
139 var tabIndex = $.attr( element, "tabindex" ),
140 isTabIndexNaN = isNaN( tabIndex );
141 return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN );
142 }
143 });
144
145 // support: jQuery <1.8
146 if ( !$( "<a>" ).outerWidth( 1 ).jquery ) {
147 $.each( [ "Width", "Height" ], function( i, name ) {
148 var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
149 type = name.toLowerCase(),
150 orig = {
151 innerWidth: $.fn.innerWidth,
152 innerHeight: $.fn.innerHeight,
153 outerWidth: $.fn.outerWidth,
154 outerHeight: $.fn.outerHeight
155 };
156
157 function reduce( elem, size, border, margin ) {
158 $.each( side, function() {
159 size -= parseFloat( $.css( elem, "padding" + this ) ) || 0;
160 if ( border ) {
161 size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0;
162 }
163 if ( margin ) {
164 size -= parseFloat( $.css( elem, "margin" + this ) ) || 0;
165 }
166 });
167 return size;
168 }
169
170 $.fn[ "inner" + name ] = function( size ) {
171 if ( size === undefined ) {
172 return orig[ "inner" + name ].call( this );
173 }
174
175 return this.each(function() {
176 $( this ).css( type, reduce( this, size ) + "px" );
177 });
178 };
179
180 $.fn[ "outer" + name] = function( size, margin ) {
181 if ( typeof size !== "number" ) {
182 return orig[ "outer" + name ].call( this, size );
183 }
184
185 return this.each(function() {
186 $( this).css( type, reduce( this, size, true, margin ) + "px" );
187 });
188 };
189 });
190 }
191
192 // support: jQuery <1.8
193 if ( !$.fn.addBack ) {
194 $.fn.addBack = function( selector ) {
195 return this.add( selector == null ?
196 this.prevObject : this.prevObject.filter( selector )
197 );
198 };
199 }
200
201 // support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413)
202 if ( $( "<a>" ).data( "a-b", "a" ).removeData( "a-b" ).data( "a-b" ) ) {
203 $.fn.removeData = (function( removeData ) {
204 return function( key ) {
205 if ( arguments.length ) {
206 return removeData.call( this, $.camelCase( key ) );
207 } else {
208 return removeData.call( this );
209 }
210 };
211 })( $.fn.removeData );
212 }
213
214 // deprecated
215 $.ui.ie = !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() );
216
217 $.fn.extend({
218 focus: (function( orig ) {
219 return function( delay, fn ) {
220 return typeof delay === "number" ?
221 this.each(function() {
222 var elem = this;
223 setTimeout(function() {
224 $( elem ).focus();
225 if ( fn ) {
226 fn.call( elem );
227 }
228 }, delay );
229 }) :
230 orig.apply( this, arguments );
231 };
232 })( $.fn.focus ),
233
234 disableSelection: (function() {
235 var eventType = "onselectstart" in document.createElement( "div" ) ?
236 "selectstart" :
237 "mousedown";
238
239 return function() {
240 return this.bind( eventType + ".ui-disableSelection", function( event ) {
241 event.preventDefault();
242 });
243 };
244 })(),
245
246 enableSelection: function() {
247 return this.unbind( ".ui-disableSelection" );
248 },
249
250 zIndex: function( zIndex ) {
251 if ( zIndex !== undefined ) {
252 return this.css( "zIndex", zIndex );
253 }
254
255 if ( this.length ) {
256 var elem = $( this[ 0 ] ), position, value;
257 while ( elem.length && elem[ 0 ] !== document ) {
258 // Ignore z-index if position is set to a value where z-index is ignored by the browser
259 // This makes behavior of this function consistent across browsers
260 // WebKit always returns auto if the element is positioned
261 position = elem.css( "position" );
262 if ( position === "absolute" || position === "relative" || position === "fixed" ) {
263 // IE returns 0 when zIndex is not specified
264 // other browsers return a string
265 // we ignore the case of nested elements with an explicit value of 0
266 // <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
267 value = parseInt( elem.css( "zIndex" ), 10 );
268 if ( !isNaN( value ) && value !== 0 ) {
269 return value;
270 }
271 }
272 elem = elem.parent();
273 }
274 }
275
276 return 0;
277 }
278 });
279
280 // $.ui.plugin is deprecated. Use $.widget() extensions instead.
281 $.ui.plugin = {
282 add: function( module, option, set ) {
283 var i,
284 proto = $.ui[ module ].prototype;
285 for ( i in set ) {
286 proto.plugins[ i ] = proto.plugins[ i ] || [];
287 proto.plugins[ i ].push( [ option, set[ i ] ] );
288 }
289 },
290 call: function( instance, name, args, allowDisconnected ) {
291 var i,
292 set = instance.plugins[ name ];
293
294 if ( !set ) {
295 return;
296 }
297
298 if ( !allowDisconnected && ( !instance.element[ 0 ].parentNode || instance.element[ 0 ].parentNode.nodeType === 11 ) ) {
299 return;
300 }
301
302 for ( i = 0; i < set.length; i++ ) {
303 if ( instance.options[ set[ i ][ 0 ] ] ) {
304 set[ i ][ 1 ].apply( instance.element, args );
305 }
306 }
307 }
308 };
309
310
311 /*!
312 * jQuery UI Widget 1.11.4
313 * http://jqueryui.com
314 *
315 * Copyright jQuery Foundation and other contributors
316 * Released under the MIT license.
317 * http://jquery.org/license
318 *
319 * http://api.jqueryui.com/jQuery.widget/
320 */
321
322
323 var widget_uuid = 0,
324 widget_slice = Array.prototype.slice;
325
326 $.cleanData = (function( orig ) {
327 return function( elems ) {
328 var events, elem, i;
329 for ( i = 0; (elem = elems[i]) != null; i++ ) {
330 try {
331
332 // Only trigger remove when necessary to save time
333 events = $._data( elem, "events" );
334 if ( events && events.remove ) {
335 $( elem ).triggerHandler( "remove" );
336 }
337
338 // http://bugs.jquery.com/ticket/8235
339 } catch ( e ) {}
340 }
341 orig( elems );
342 };
343 })( $.cleanData );
344
345 $.widget = function( name, base, prototype ) {
346 var fullName, existingConstructor, constructor, basePrototype,
347 // proxiedPrototype allows the provided prototype to remain unmodified
348 // so that it can be used as a mixin for multiple widgets (#8876)
349 proxiedPrototype = {},
350 namespace = name.split( "." )[ 0 ];
351
352 name = name.split( "." )[ 1 ];
353 fullName = namespace + "-" + name;
354
355 if ( !prototype ) {
356 prototype = base;
357 base = $.Widget;
358 }
359
360 // create selector for plugin
361 $.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
362 return !!$.data( elem, fullName );
363 };
364
365 $[ namespace ] = $[ namespace ] || {};
366 existingConstructor = $[ namespace ][ name ];
367 constructor = $[ namespace ][ name ] = function( options, element ) {
368 // allow instantiation without "new" keyword
369 if ( !this._createWidget ) {
370 return new constructor( options, element );
371 }
372
373 // allow instantiation without initializing for simple inheritance
374 // must use "new" keyword (the code above always passes args)
375 if ( arguments.length ) {
376 this._createWidget( options, element );
377 }
378 };
379 // extend with the existing constructor to carry over any static properties
380 $.extend( constructor, existingConstructor, {
381 version: prototype.version,
382 // copy the object used to create the prototype in case we need to
383 // redefine the widget later
384 _proto: $.extend( {}, prototype ),
385 // track widgets that inherit from this widget in case this widget is
386 // redefined after a widget inherits from it
387 _childConstructors: []
388 });
389
390 basePrototype = new base();
391 // we need to make the options hash a property directly on the new instance
392 // otherwise we'll modify the options hash on the prototype that we're
393 // inheriting from
394 basePrototype.options = $.widget.extend( {}, basePrototype.options );
395 $.each( prototype, function( prop, value ) {
396 if ( !$.isFunction( value ) ) {
397 proxiedPrototype[ prop ] = value;
398 return;
399 }
400 proxiedPrototype[ prop ] = (function() {
401 var _super = function() {
402 return base.prototype[ prop ].apply( this, arguments );
403 },
404 _superApply = function( args ) {
405 return base.prototype[ prop ].apply( this, args );
406 };
407 return function() {
408 var __super = this._super,
409 __superApply = this._superApply,
410 returnValue;
411
412 this._super = _super;
413 this._superApply = _superApply;
414
415 returnValue = value.apply( this, arguments );
416
417 this._super = __super;
418 this._superApply = __superApply;
419
420 return returnValue;
421 };
422 })();
423 });
424 constructor.prototype = $.widget.extend( basePrototype, {
425 // TODO: remove support for widgetEventPrefix
426 // always use the name + a colon as the prefix, e.g., draggable:start
427 // don't prefix for widgets that aren't DOM-based
428 widgetEventPrefix: existingConstructor ? (basePrototype.widgetEventPrefix || name) : name
429 }, proxiedPrototype, {
430 constructor: constructor,
431 namespace: namespace,
432 widgetName: name,
433 widgetFullName: fullName
434 });
435
436 // If this widget is being redefined then we need to find all widgets that
437 // are inheriting from it and redefine all of them so that they inherit from
438 // the new version of this widget. We're essentially trying to replace one
439 // level in the prototype chain.
440 if ( existingConstructor ) {
441 $.each( existingConstructor._childConstructors, function( i, child ) {
442 var childPrototype = child.prototype;
443
444 // redefine the child widget using the same prototype that was
445 // originally used, but inherit from the new version of the base
446 $.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );
447 });
448 // remove the list of existing child constructors from the old constructor
449 // so the old child constructors can be garbage collected
450 delete existingConstructor._childConstructors;
451 } else {
452 base._childConstructors.push( constructor );
453 }
454
455 $.widget.bridge( name, constructor );
456
457 return constructor;
458 };
459
460 $.widget.extend = function( target ) {
461 var input = widget_slice.call( arguments, 1 ),
462 inputIndex = 0,
463 inputLength = input.length,
464 key,
465 value;
466 for ( ; inputIndex < inputLength; inputIndex++ ) {
467 for ( key in input[ inputIndex ] ) {
468 value = input[ inputIndex ][ key ];
469 if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
470 // Clone objects
471 if ( $.isPlainObject( value ) ) {
472 target[ key ] = $.isPlainObject( target[ key ] ) ?
473 $.widget.extend( {}, target[ key ], value ) :
474 // Don't extend strings, arrays, etc. with objects
475 $.widget.extend( {}, value );
476 // Copy everything else by reference
477 } else {
478 target[ key ] = value;
479 }
480 }
481 }
482 }
483 return target;
484 };
485
486 $.widget.bridge = function( name, object ) {
487 var fullName = object.prototype.widgetFullName || name;
488 $.fn[ name ] = function( options ) {
489 var isMethodCall = typeof options === "string",
490 args = widget_slice.call( arguments, 1 ),
491 returnValue = this;
492
493 if ( isMethodCall ) {
494 this.each(function() {
495 var methodValue,
496 instance = $.data( this, fullName );
497 if ( options === "instance" ) {
498 returnValue = instance;
499 return false;
500 }
501 if ( !instance ) {
502 return $.error( "cannot call methods on " + name + " prior to initialization; " +
503 "attempted to call method '" + options + "'" );
504 }
505 if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) {
506 return $.error( "no such method '" + options + "' for " + name + " widget instance" );
507 }
508 methodValue = instance[ options ].apply( instance, args );
509 if ( methodValue !== instance && methodValue !== undefined ) {
510 returnValue = methodValue && methodValue.jquery ?
511 returnValue.pushStack( methodValue.get() ) :
512 methodValue;
513 return false;
514 }
515 });
516 } else {
517
518 // Allow multiple hashes to be passed on init
519 if ( args.length ) {
520 options = $.widget.extend.apply( null, [ options ].concat(args) );
521 }
522
523 this.each(function() {
524 var instance = $.data( this, fullName );
525 if ( instance ) {
526 instance.option( options || {} );
527 if ( instance._init ) {
528 instance._init();
529 }
530 } else {
531 $.data( this, fullName, new object( options, this ) );
532 }
533 });
534 }
535
536 return returnValue;
537 };
538 };
539
540 $.Widget = function( /* options, element */ ) {};
541 $.Widget._childConstructors = [];
542
543 $.Widget.prototype = {
544 widgetName: "widget",
545 widgetEventPrefix: "",
546 defaultElement: "<div>",
547 options: {
548 disabled: false,
549
550 // callbacks
551 create: null
552 },
553 _createWidget: function( options, element ) {
554 element = $( element || this.defaultElement || this )[ 0 ];
555 this.element = $( element );
556 this.uuid = widget_uuid++;
557 this.eventNamespace = "." + this.widgetName + this.uuid;
558
559 this.bindings = $();
560 this.hoverable = $();
561 this.focusable = $();
562
563 if ( element !== this ) {
564 $.data( element, this.widgetFullName, this );
565 this._on( true, this.element, {
566 remove: function( event ) {
567 if ( event.target === element ) {
568 this.destroy();
569 }
570 }
571 });
572 this.document = $( element.style ?
573 // element within the document
574 element.ownerDocument :
575 // element is window or document
576 element.document || element );
577 this.window = $( this.document[0].defaultView || this.document[0].parentWindow );
578 }
579
580 this.options = $.widget.extend( {},
581 this.options,
582 this._getCreateOptions(),
583 options );
584
585 this._create();
586 this._trigger( "create", null, this._getCreateEventData() );
587 this._init();
588 },
589 _getCreateOptions: $.noop,
590 _getCreateEventData: $.noop,
591 _create: $.noop,
592 _init: $.noop,
593
594 destroy: function() {
595 this._destroy();
596 // we can probably remove the unbind calls in 2.0
597 // all event bindings should go through this._on()
598 this.element
599 .unbind( this.eventNamespace )
600 .removeData( this.widgetFullName )
601 // support: jquery <1.6.3
602 // http://bugs.jquery.com/ticket/9413
603 .removeData( $.camelCase( this.widgetFullName ) );
604 this.widget()
605 .unbind( this.eventNamespace )
606 .removeAttr( "aria-disabled" )
607 .removeClass(
608 this.widgetFullName + "-disabled " +
609 "ui-state-disabled" );
610
611 // clean up events and states
612 this.bindings.unbind( this.eventNamespace );
613 this.hoverable.removeClass( "ui-state-hover" );
614 this.focusable.removeClass( "ui-state-focus" );
615 },
616 _destroy: $.noop,
617
618 widget: function() {
619 return this.element;
620 },
621
622 option: function( key, value ) {
623 var options = key,
624 parts,
625 curOption,
626 i;
627
628 if ( arguments.length === 0 ) {
629 // don't return a reference to the internal hash
630 return $.widget.extend( {}, this.options );
631 }
632
633 if ( typeof key === "string" ) {
634 // handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
635 options = {};
636 parts = key.split( "." );
637 key = parts.shift();
638 if ( parts.length ) {
639 curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
640 for ( i = 0; i < parts.length - 1; i++ ) {
641 curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
642 curOption = curOption[ parts[ i ] ];
643 }
644 key = parts.pop();
645 if ( arguments.length === 1 ) {
646 return curOption[ key ] === undefined ? null : curOption[ key ];
647 }
648 curOption[ key ] = value;
649 } else {
650 if ( arguments.length === 1 ) {
651 return this.options[ key ] === undefined ? null : this.options[ key ];
652 }
653 options[ key ] = value;
654 }
655 }
656
657 this._setOptions( options );
658
659 return this;
660 },
661 _setOptions: function( options ) {
662 var key;
663
664 for ( key in options ) {
665 this._setOption( key, options[ key ] );
666 }
667
668 return this;
669 },
670 _setOption: function( key, value ) {
671 this.options[ key ] = value;
672
673 if ( key === "disabled" ) {
674 this.widget()
675 .toggleClass( this.widgetFullName + "-disabled", !!value );
676
677 // If the widget is becoming disabled, then nothing is interactive
678 if ( value ) {
679 this.hoverable.removeClass( "ui-state-hover" );
680 this.focusable.removeClass( "ui-state-focus" );
681 }
682 }
683
684 return this;
685 },
686
687 enable: function() {
688 return this._setOptions({ disabled: false });
689 },
690 disable: function() {
691 return this._setOptions({ disabled: true });
692 },
693
694 _on: function( suppressDisabledCheck, element, handlers ) {
695 var delegateElement,
696 instance = this;
697
698 // no suppressDisabledCheck flag, shuffle arguments
699 if ( typeof suppressDisabledCheck !== "boolean" ) {
700 handlers = element;
701 element = suppressDisabledCheck;
702 suppressDisabledCheck = false;
703 }
704
705 // no element argument, shuffle and use this.element
706 if ( !handlers ) {
707 handlers = element;
708 element = this.element;
709 delegateElement = this.widget();
710 } else {
711 element = delegateElement = $( element );
712 this.bindings = this.bindings.add( element );
713 }
714
715 $.each( handlers, function( event, handler ) {
716 function handlerProxy() {
717 // allow widgets to customize the disabled handling
718 // - disabled as an array instead of boolean
719 // - disabled class as method for disabling individual parts
720 if ( !suppressDisabledCheck &&
721 ( instance.options.disabled === true ||
722 $( this ).hasClass( "ui-state-disabled" ) ) ) {
723 return;
724 }
725 return ( typeof handler === "string" ? instance[ handler ] : handler )
726 .apply( instance, arguments );
727 }
728
729 // copy the guid so direct unbinding works
730 if ( typeof handler !== "string" ) {
731 handlerProxy.guid = handler.guid =
732 handler.guid || handlerProxy.guid || $.guid++;
733 }
734
735 var match = event.match( /^([\w:-]*)\s*(.*)$/ ),
736 eventName = match[1] + instance.eventNamespace,
737 selector = match[2];
738 if ( selector ) {
739 delegateElement.delegate( selector, eventName, handlerProxy );
740 } else {
741 element.bind( eventName, handlerProxy );
742 }
743 });
744 },
745
746 _off: function( element, eventName ) {
747 eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) +
748 this.eventNamespace;
749 element.unbind( eventName ).undelegate( eventName );
750
751 // Clear the stack to avoid memory leaks (#10056)
752 this.bindings = $( this.bindings.not( element ).get() );
753 this.focusable = $( this.focusable.not( element ).get() );
754 this.hoverable = $( this.hoverable.not( element ).get() );
755 },
756
757 _delay: function( handler, delay ) {
758 function handlerProxy() {
759 return ( typeof handler === "string" ? instance[ handler ] : handler )
760 .apply( instance, arguments );
761 }
762 var instance = this;
763 return setTimeout( handlerProxy, delay || 0 );
764 },
765
766 _hoverable: function( element ) {
767 this.hoverable = this.hoverable.add( element );
768 this._on( element, {
769 mouseenter: function( event ) {
770 $( event.currentTarget ).addClass( "ui-state-hover" );
771 },
772 mouseleave: function( event ) {
773 $( event.currentTarget ).removeClass( "ui-state-hover" );
774 }
775 });
776 },
777
778 _focusable: function( element ) {
779 this.focusable = this.focusable.add( element );
780 this._on( element, {
781 focusin: function( event ) {
782 $( event.currentTarget ).addClass( "ui-state-focus" );
783 },
784 focusout: function( event ) {
785 $( event.currentTarget ).removeClass( "ui-state-focus" );
786 }
787 });
788 },
789
790 _trigger: function( type, event, data ) {
791 var prop, orig,
792 callback = this.options[ type ];
793
794 data = data || {};
795 event = $.Event( event );
796 event.type = ( type === this.widgetEventPrefix ?
797 type :
798 this.widgetEventPrefix + type ).toLowerCase();
799 // the original event may come from any element
800 // so we need to reset the target on the new event
801 event.target = this.element[ 0 ];
802
803 // copy original event properties over to the new event
804 orig = event.originalEvent;
805 if ( orig ) {
806 for ( prop in orig ) {
807 if ( !( prop in event ) ) {
808 event[ prop ] = orig[ prop ];
809 }
810 }
811 }
812
813 this.element.trigger( event, data );
814 return !( $.isFunction( callback ) &&
815 callback.apply( this.element[0], [ event ].concat( data ) ) === false ||
816 event.isDefaultPrevented() );
817 }
818 };
819
820 $.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
821 $.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
822 if ( typeof options === "string" ) {
823 options = { effect: options };
824 }
825 var hasOptions,
826 effectName = !options ?
827 method :
828 options === true || typeof options === "number" ?
829 defaultEffect :
830 options.effect || defaultEffect;
831 options = options || {};
832 if ( typeof options === "number" ) {
833 options = { duration: options };
834 }
835 hasOptions = !$.isEmptyObject( options );
836 options.complete = callback;
837 if ( options.delay ) {
838 element.delay( options.delay );
839 }
840 if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
841 element[ method ]( options );
842 } else if ( effectName !== method && element[ effectName ] ) {
843 element[ effectName ]( options.duration, options.easing, callback );
844 } else {
845 element.queue(function( next ) {
846 $( this )[ method ]();
847 if ( callback ) {
848 callback.call( element[ 0 ] );
849 }
850 next();
851 });
852 }
853 };
854 });
855
856 var widget = $.widget;
857
858
859 /*!
860 * jQuery UI Mouse 1.11.4
861 * http://jqueryui.com
862 *
863 * Copyright jQuery Foundation and other contributors
864 * Released under the MIT license.
865 * http://jquery.org/license
866 *
867 * http://api.jqueryui.com/mouse/
868 */
869
870
871 var mouseHandled = false;
872 $( document ).mouseup( function() {
873 mouseHandled = false;
874 });
875
876 var mouse = $.widget("ui.mouse", {
877 version: "1.11.4",
878 options: {
879 cancel: "input,textarea,button,select,option",
880 distance: 1,
881 delay: 0
882 },
883 _mouseInit: function() {
884 var that = this;
885
886 this.element
887 .bind("mousedown." + this.widgetName, function(event) {
888 return that._mouseDown(event);
889 })
890 .bind("click." + this.widgetName, function(event) {
891 if (true === $.data(event.target, that.widgetName + ".preventClickEvent")) {
892 $.removeData(event.target, that.widgetName + ".preventClickEvent");
893 event.stopImmediatePropagation();
894 return false;
895 }
896 });
897
898 this.started = false;
899 },
900
901 // TODO: make sure destroying one instance of mouse doesn't mess with
902 // other instances of mouse
903 _mouseDestroy: function() {
904 this.element.unbind("." + this.widgetName);
905 if ( this._mouseMoveDelegate ) {
906 this.document
907 .unbind("mousemove." + this.widgetName, this._mouseMoveDelegate)
908 .unbind("mouseup." + this.widgetName, this._mouseUpDelegate);
909 }
910 },
911
912 _mouseDown: function(event) {
913 // don't let more than one widget handle mouseStart
914 if ( mouseHandled ) {
915 return;
916 }
917
918 this._mouseMoved = false;
919
920 // we may have missed mouseup (out of window)
921 (this._mouseStarted && this._mouseUp(event));
922
923 this._mouseDownEvent = event;
924
925 var that = this,
926 btnIsLeft = (event.which === 1),
927 // event.target.nodeName works around a bug in IE 8 with
928 // disabled inputs (#7620)
929 elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ? $(event.target).closest(this.options.cancel).length : false);
930 if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
931 return true;
932 }
933
934 this.mouseDelayMet = !this.options.delay;
935 if (!this.mouseDelayMet) {
936 this._mouseDelayTimer = setTimeout(function() {
937 that.mouseDelayMet = true;
938 }, this.options.delay);
939 }
940
941 if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
942 this._mouseStarted = (this._mouseStart(event) !== false);
943 if (!this._mouseStarted) {
944 event.preventDefault();
945 return true;
946 }
947 }
948
949 // Click event may never have fired (Gecko & Opera)
950 if (true === $.data(event.target, this.widgetName + ".preventClickEvent")) {
951 $.removeData(event.target, this.widgetName + ".preventClickEvent");
952 }
953
954 // these delegates are required to keep context
955 this._mouseMoveDelegate = function(event) {
956 return that._mouseMove(event);
957 };
958 this._mouseUpDelegate = function(event) {
959 return that._mouseUp(event);
960 };
961
962 this.document
963 .bind( "mousemove." + this.widgetName, this._mouseMoveDelegate )
964 .bind( "mouseup." + this.widgetName, this._mouseUpDelegate );
965
966 event.preventDefault();
967
968 mouseHandled = true;
969 return true;
970 },
971
972 _mouseMove: function(event) {
973 // Only check for mouseups outside the document if you've moved inside the document
974 // at least once. This prevents the firing of mouseup in the case of IE<9, which will
975 // fire a mousemove event if content is placed under the cursor. See #7778
976 // Support: IE <9
977 if ( this._mouseMoved ) {
978 // IE mouseup check - mouseup happened when mouse was out of window
979 if ($.ui.ie && ( !document.documentMode || document.documentMode < 9 ) && !event.button) {
980 return this._mouseUp(event);
981
982 // Iframe mouseup check - mouseup occurred in another document
983 } else if ( !event.which ) {
984 return this._mouseUp( event );
985 }
986 }
987
988 if ( event.which || event.button ) {
989 this._mouseMoved = true;
990 }
991
992 if (this._mouseStarted) {
993 this._mouseDrag(event);
994 return event.preventDefault();
995 }
996
997 if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
998 this._mouseStarted =
999 (this._mouseStart(this._mouseDownEvent, event) !== false);
1000 (this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
1001 }
1002
1003 return !this._mouseStarted;
1004 },
1005
1006 _mouseUp: function(event) {
1007 this.document
1008 .unbind( "mousemove." + this.widgetName, this._mouseMoveDelegate )
1009 .unbind( "mouseup." + this.widgetName, this._mouseUpDelegate );
1010
1011 if (this._mouseStarted) {
1012 this._mouseStarted = false;
1013
1014 if (event.target === this._mouseDownEvent.target) {
1015 $.data(event.target, this.widgetName + ".preventClickEvent", true);
1016 }
1017
1018 this._mouseStop(event);
1019 }
1020
1021 mouseHandled = false;
1022 return false;
1023 },
1024
1025 _mouseDistanceMet: function(event) {
1026 return (Math.max(
1027 Math.abs(this._mouseDownEvent.pageX - event.pageX),
1028 Math.abs(this._mouseDownEvent.pageY - event.pageY)
1029 ) >= this.options.distance
1030 );
1031 },
1032
1033 _mouseDelayMet: function(/* event */) {
1034 return this.mouseDelayMet;
1035 },
1036
1037 // These are placeholder methods, to be overriden by extending plugin
1038 _mouseStart: function(/* event */) {},
1039 _mouseDrag: function(/* event */) {},
1040 _mouseStop: function(/* event */) {},
1041 _mouseCapture: function(/* event */) { return true; }
1042 });
1043
1044
1045 /*!
1046 * jQuery UI Position 1.11.4
1047 * http://jqueryui.com
1048 *
1049 * Copyright jQuery Foundation and other contributors
1050 * Released under the MIT license.
1051 * http://jquery.org/license
1052 *
1053 * http://api.jqueryui.com/position/
1054 */
1055
1056 (function() {
1057
1058 $.ui = $.ui || {};
1059
1060 var cachedScrollbarWidth, supportsOffsetFractions,
1061 max = Math.max,
1062 abs = Math.abs,
1063 round = Math.round,
1064 rhorizontal = /left|center|right/,
1065 rvertical = /top|center|bottom/,
1066 roffset = /[\+\-]\d+(\.[\d]+)?%?/,
1067 rposition = /^\w+/,
1068 rpercent = /%$/,
1069 _position = $.fn.position;
1070
1071 function getOffsets( offsets, width, height ) {
1072 return [
1073 parseFloat( offsets[ 0 ] ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ),
1074 parseFloat( offsets[ 1 ] ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 )
1075 ];
1076 }
1077
1078 function parseCss( element, property ) {
1079 return parseInt( $.css( element, property ), 10 ) || 0;
1080 }
1081
1082 function getDimensions( elem ) {
1083 var raw = elem[0];
1084 if ( raw.nodeType === 9 ) {
1085 return {
1086 width: elem.width(),
1087 height: elem.height(),
1088 offset: { top: 0, left: 0 }
1089 };
1090 }
1091 if ( $.isWindow( raw ) ) {
1092 return {
1093 width: elem.width(),
1094 height: elem.height(),
1095 offset: { top: elem.scrollTop(), left: elem.scrollLeft() }
1096 };
1097 }
1098 if ( raw.preventDefault ) {
1099 return {
1100 width: 0,
1101 height: 0,
1102 offset: { top: raw.pageY, left: raw.pageX }
1103 };
1104 }
1105 return {
1106 width: elem.outerWidth(),
1107 height: elem.outerHeight(),
1108 offset: elem.offset()
1109 };
1110 }
1111
1112 $.position = {
1113 scrollbarWidth: function() {
1114 if ( cachedScrollbarWidth !== undefined ) {
1115 return cachedScrollbarWidth;
1116 }
1117 var w1, w2,
1118 div = $( "<div style='display:block;position:absolute;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>" ),
1119 innerDiv = div.children()[0];
1120
1121 $( "body" ).append( div );
1122 w1 = innerDiv.offsetWidth;
1123 div.css( "overflow", "scroll" );
1124
1125 w2 = innerDiv.offsetWidth;
1126
1127 if ( w1 === w2 ) {
1128 w2 = div[0].clientWidth;
1129 }
1130
1131 div.remove();
1132
1133 return (cachedScrollbarWidth = w1 - w2);
1134 },
1135 getScrollInfo: function( within ) {
1136 var overflowX = within.isWindow || within.isDocument ? "" :
1137 within.element.css( "overflow-x" ),
1138 overflowY = within.isWindow || within.isDocument ? "" :
1139 within.element.css( "overflow-y" ),
1140 hasOverflowX = overflowX === "scroll" ||
1141 ( overflowX === "auto" && within.width < within.element[0].scrollWidth ),
1142 hasOverflowY = overflowY === "scroll" ||
1143 ( overflowY === "auto" && within.height < within.element[0].scrollHeight );
1144 return {
1145 width: hasOverflowY ? $.position.scrollbarWidth() : 0,
1146 height: hasOverflowX ? $.position.scrollbarWidth() : 0
1147 };
1148 },
1149 getWithinInfo: function( element ) {
1150 var withinElement = $( element || window ),
1151 isWindow = $.isWindow( withinElement[0] ),
1152 isDocument = !!withinElement[ 0 ] && withinElement[ 0 ].nodeType === 9;
1153 return {
1154 element: withinElement,
1155 isWindow: isWindow,
1156 isDocument: isDocument,
1157 offset: withinElement.offset() || { left: 0, top: 0 },
1158 scrollLeft: withinElement.scrollLeft(),
1159 scrollTop: withinElement.scrollTop(),
1160
1161 // support: jQuery 1.6.x
1162 // jQuery 1.6 doesn't support .outerWidth/Height() on documents or windows
1163 width: isWindow || isDocument ? withinElement.width() : withinElement.outerWidth(),
1164 height: isWindow || isDocument ? withinElement.height() : withinElement.outerHeight()
1165 };
1166 }
1167 };
1168
1169 $.fn.position = function( options ) {
1170 if ( !options || !options.of ) {
1171 return _position.apply( this, arguments );
1172 }
1173
1174 // make a copy, we don't want to modify arguments
1175 options = $.extend( {}, options );
1176
1177 var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,
1178 target = $( options.of ),
1179 within = $.position.getWithinInfo( options.within ),
1180 scrollInfo = $.position.getScrollInfo( within ),
1181 collision = ( options.collision || "flip" ).split( " " ),
1182 offsets = {};
1183
1184 dimensions = getDimensions( target );
1185 if ( target[0].preventDefault ) {
1186 // force left top to allow flipping
1187 options.at = "left top";
1188 }
1189 targetWidth = dimensions.width;
1190 targetHeight = dimensions.height;
1191 targetOffset = dimensions.offset;
1192 // clone to reuse original targetOffset later
1193 basePosition = $.extend( {}, targetOffset );
1194
1195 // force my and at to have valid horizontal and vertical positions
1196 // if a value is missing or invalid, it will be converted to center
1197 $.each( [ "my", "at" ], function() {
1198 var pos = ( options[ this ] || "" ).split( " " ),
1199 horizontalOffset,
1200 verticalOffset;
1201
1202 if ( pos.length === 1) {
1203 pos = rhorizontal.test( pos[ 0 ] ) ?
1204 pos.concat( [ "center" ] ) :
1205 rvertical.test( pos[ 0 ] ) ?
1206 [ "center" ].concat( pos ) :
1207 [ "center", "center" ];
1208 }
1209 pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";
1210 pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";
1211
1212 // calculate offsets
1213 horizontalOffset = roffset.exec( pos[ 0 ] );
1214 verticalOffset = roffset.exec( pos[ 1 ] );
1215 offsets[ this ] = [
1216 horizontalOffset ? horizontalOffset[ 0 ] : 0,
1217 verticalOffset ? verticalOffset[ 0 ] : 0
1218 ];
1219
1220 // reduce to just the positions without the offsets
1221 options[ this ] = [
1222 rposition.exec( pos[ 0 ] )[ 0 ],
1223 rposition.exec( pos[ 1 ] )[ 0 ]
1224 ];
1225 });
1226
1227 // normalize collision option
1228 if ( collision.length === 1 ) {
1229 collision[ 1 ] = collision[ 0 ];
1230 }
1231
1232 if ( options.at[ 0 ] === "right" ) {
1233 basePosition.left += targetWidth;
1234 } else if ( options.at[ 0 ] === "center" ) {
1235 basePosition.left += targetWidth / 2;
1236 }
1237
1238 if ( options.at[ 1 ] === "bottom" ) {
1239 basePosition.top += targetHeight;
1240 } else if ( options.at[ 1 ] === "center" ) {
1241 basePosition.top += targetHeight / 2;
1242 }
1243
1244 atOffset = getOffsets( offsets.at, targetWidth, targetHeight );
1245 basePosition.left += atOffset[ 0 ];
1246 basePosition.top += atOffset[ 1 ];
1247
1248 return this.each(function() {
1249 var collisionPosition, using,
1250 elem = $( this ),
1251 elemWidth = elem.outerWidth(),
1252 elemHeight = elem.outerHeight(),
1253 marginLeft = parseCss( this, "marginLeft" ),
1254 marginTop = parseCss( this, "marginTop" ),
1255 collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) + scrollInfo.width,
1256 collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) + scrollInfo.height,
1257 position = $.extend( {}, basePosition ),
1258 myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() );
1259
1260 if ( options.my[ 0 ] === "right" ) {
1261 position.left -= elemWidth;
1262 } else if ( options.my[ 0 ] === "center" ) {
1263 position.left -= elemWidth / 2;
1264 }
1265
1266 if ( options.my[ 1 ] === "bottom" ) {
1267 position.top -= elemHeight;
1268 } else if ( options.my[ 1 ] === "center" ) {
1269 position.top -= elemHeight / 2;
1270 }
1271
1272 position.left += myOffset[ 0 ];
1273 position.top += myOffset[ 1 ];
1274
1275 // if the browser doesn't support fractions, then round for consistent results
1276 if ( !supportsOffsetFractions ) {
1277 position.left = round( position.left );
1278 position.top = round( position.top );
1279 }
1280
1281 collisionPosition = {
1282 marginLeft: marginLeft,
1283 marginTop: marginTop
1284 };
1285
1286 $.each( [ "left", "top" ], function( i, dir ) {
1287 if ( $.ui.position[ collision[ i ] ] ) {
1288 $.ui.position[ collision[ i ] ][ dir ]( position, {
1289 targetWidth: targetWidth,
1290 targetHeight: targetHeight,
1291 elemWidth: elemWidth,
1292 elemHeight: elemHeight,
1293 collisionPosition: collisionPosition,
1294 collisionWidth: collisionWidth,
1295 collisionHeight: collisionHeight,
1296 offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ],
1297 my: options.my,
1298 at: options.at,
1299 within: within,
1300 elem: elem
1301 });
1302 }
1303 });
1304
1305 if ( options.using ) {
1306 // adds feedback as second argument to using callback, if present
1307 using = function( props ) {
1308 var left = targetOffset.left - position.left,
1309 right = left + targetWidth - elemWidth,
1310 top = targetOffset.top - position.top,
1311 bottom = top + targetHeight - elemHeight,
1312 feedback = {
1313 target: {
1314 element: target,
1315 left: targetOffset.left,
1316 top: targetOffset.top,
1317 width: targetWidth,
1318 height: targetHeight
1319 },
1320 element: {
1321 element: elem,
1322 left: position.left,
1323 top: position.top,
1324 width: elemWidth,
1325 height: elemHeight
1326 },
1327 horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
1328 vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
1329 };
1330 if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) {
1331 feedback.horizontal = "center";
1332 }
1333 if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) {
1334 feedback.vertical = "middle";
1335 }
1336 if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) {
1337 feedback.important = "horizontal";
1338 } else {
1339 feedback.important = "vertical";
1340 }
1341 options.using.call( this, props, feedback );
1342 };
1343 }
1344
1345 elem.offset( $.extend( position, { using: using } ) );
1346 });
1347 };
1348
1349 $.ui.position = {
1350 fit: {
1351 left: function( position, data ) {
1352 var within = data.within,
1353 withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
1354 outerWidth = within.width,
1355 collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1356 overLeft = withinOffset - collisionPosLeft,
1357 overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
1358 newOverRight;
1359
1360 // element is wider than within
1361 if ( data.collisionWidth > outerWidth ) {
1362 // element is initially over the left side of within
1363 if ( overLeft > 0 && overRight <= 0 ) {
1364 newOverRight = position.left + overLeft + data.collisionWidth - outerWidth - withinOffset;
1365 position.left += overLeft - newOverRight;
1366 // element is initially over right side of within
1367 } else if ( overRight > 0 && overLeft <= 0 ) {
1368 position.left = withinOffset;
1369 // element is initially over both left and right sides of within
1370 } else {
1371 if ( overLeft > overRight ) {
1372 position.left = withinOffset + outerWidth - data.collisionWidth;
1373 } else {
1374 position.left = withinOffset;
1375 }
1376 }
1377 // too far left -> align with left edge
1378 } else if ( overLeft > 0 ) {
1379 position.left += overLeft;
1380 // too far right -> align with right edge
1381 } else if ( overRight > 0 ) {
1382 position.left -= overRight;
1383 // adjust based on position and margin
1384 } else {
1385 position.left = max( position.left - collisionPosLeft, position.left );
1386 }
1387 },
1388 top: function( position, data ) {
1389 var within = data.within,
1390 withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
1391 outerHeight = data.within.height,
1392 collisionPosTop = position.top - data.collisionPosition.marginTop,
1393 overTop = withinOffset - collisionPosTop,
1394 overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
1395 newOverBottom;
1396
1397 // element is taller than within
1398 if ( data.collisionHeight > outerHeight ) {
1399 // element is initially over the top of within
1400 if ( overTop > 0 && overBottom <= 0 ) {
1401 newOverBottom = position.top + overTop + data.collisionHeight - outerHeight - withinOffset;
1402 position.top += overTop - newOverBottom;
1403 // element is initially over bottom of within
1404 } else if ( overBottom > 0 && overTop <= 0 ) {
1405 position.top = withinOffset;
1406 // element is initially over both top and bottom of within
1407 } else {
1408 if ( overTop > overBottom ) {
1409 position.top = withinOffset + outerHeight - data.collisionHeight;
1410 } else {
1411 position.top = withinOffset;
1412 }
1413 }
1414 // too far up -> align with top
1415 } else if ( overTop > 0 ) {
1416 position.top += overTop;
1417 // too far down -> align with bottom edge
1418 } else if ( overBottom > 0 ) {
1419 position.top -= overBottom;
1420 // adjust based on position and margin
1421 } else {
1422 position.top = max( position.top - collisionPosTop, position.top );
1423 }
1424 }
1425 },
1426 flip: {
1427 left: function( position, data ) {
1428 var within = data.within,
1429 withinOffset = within.offset.left + within.scrollLeft,
1430 outerWidth = within.width,
1431 offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
1432 collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1433 overLeft = collisionPosLeft - offsetLeft,
1434 overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
1435 myOffset = data.my[ 0 ] === "left" ?
1436 -data.elemWidth :
1437 data.my[ 0 ] === "right" ?
1438 data.elemWidth :
1439 0,
1440 atOffset = data.at[ 0 ] === "left" ?
1441 data.targetWidth :
1442 data.at[ 0 ] === "right" ?
1443 -data.targetWidth :
1444 0,
1445 offset = -2 * data.offset[ 0 ],
1446 newOverRight,
1447 newOverLeft;
1448
1449 if ( overLeft < 0 ) {
1450 newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth - outerWidth - withinOffset;
1451 if ( newOverRight < 0 || newOverRight < abs( overLeft ) ) {
1452 position.left += myOffset + atOffset + offset;
1453 }
1454 } else if ( overRight > 0 ) {
1455 newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset + atOffset + offset - offsetLeft;
1456 if ( newOverLeft > 0 || abs( newOverLeft ) < overRight ) {
1457 position.left += myOffset + atOffset + offset;
1458 }
1459 }
1460 },
1461 top: function( position, data ) {
1462 var within = data.within,
1463 withinOffset = within.offset.top + within.scrollTop,
1464 outerHeight = within.height,
1465 offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
1466 collisionPosTop = position.top - data.collisionPosition.marginTop,
1467 overTop = collisionPosTop - offsetTop,
1468 overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
1469 top = data.my[ 1 ] === "top",
1470 myOffset = top ?
1471 -data.elemHeight :
1472 data.my[ 1 ] === "bottom" ?
1473 data.elemHeight :
1474 0,
1475 atOffset = data.at[ 1 ] === "top" ?
1476 data.targetHeight :
1477 data.at[ 1 ] === "bottom" ?
1478 -data.targetHeight :
1479 0,
1480 offset = -2 * data.offset[ 1 ],
1481 newOverTop,
1482 newOverBottom;
1483 if ( overTop < 0 ) {
1484 newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight - outerHeight - withinOffset;
1485 if ( newOverBottom < 0 || newOverBottom < abs( overTop ) ) {
1486 position.top += myOffset + atOffset + offset;
1487 }
1488 } else if ( overBottom > 0 ) {
1489 newOverTop = position.top - data.collisionPosition.marginTop + myOffset + atOffset + offset - offsetTop;
1490 if ( newOverTop > 0 || abs( newOverTop ) < overBottom ) {
1491 position.top += myOffset + atOffset + offset;
1492 }
1493 }
1494 }
1495 },
1496 flipfit: {
1497 left: function() {
1498 $.ui.position.flip.left.apply( this, arguments );
1499 $.ui.position.fit.left.apply( this, arguments );
1500 },
1501 top: function() {
1502 $.ui.position.flip.top.apply( this, arguments );
1503 $.ui.position.fit.top.apply( this, arguments );
1504 }
1505 }
1506 };
1507
1508 // fraction support test
1509 (function() {
1510 var testElement, testElementParent, testElementStyle, offsetLeft, i,
1511 body = document.getElementsByTagName( "body" )[ 0 ],
1512 div = document.createElement( "div" );
1513
1514 //Create a "fake body" for testing based on method used in jQuery.support
1515 testElement = document.createElement( body ? "div" : "body" );
1516 testElementStyle = {
1517 visibility: "hidden",
1518 width: 0,
1519 height: 0,
1520 border: 0,
1521 margin: 0,
1522 background: "none"
1523 };
1524 if ( body ) {
1525 $.extend( testElementStyle, {
1526 position: "absolute",
1527 left: "-1000px",
1528 top: "-1000px"
1529 });
1530 }
1531 for ( i in testElementStyle ) {
1532 testElement.style[ i ] = testElementStyle[ i ];
1533 }
1534 testElement.appendChild( div );
1535 testElementParent = body || document.documentElement;
1536 testElementParent.insertBefore( testElement, testElementParent.firstChild );
1537
1538 div.style.cssText = "position: absolute; left: 10.7432222px;";
1539
1540 offsetLeft = $( div ).offset().left;
1541 supportsOffsetFractions = offsetLeft > 10 && offsetLeft < 11;
1542
1543 testElement.innerHTML = "";
1544 testElementParent.removeChild( testElement );
1545 })();
1546
1547 })();
1548
1549 var position = $.ui.position;
1550
1551
1552 /*!
1553 * jQuery UI Accordion 1.11.4
1554 * http://jqueryui.com
1555 *
1556 * Copyright jQuery Foundation and other contributors
1557 * Released under the MIT license.
1558 * http://jquery.org/license
1559 *
1560 * http://api.jqueryui.com/accordion/
1561 */
1562
1563
1564 var accordion = $.widget( "ui.accordion", {
1565 version: "1.11.4",
1566 options: {
1567 active: 0,
1568 animate: {},
1569 collapsible: false,
1570 event: "click",
1571 header: "> li > :first-child,> :not(li):even",
1572 heightStyle: "auto",
1573 icons: {
1574 activeHeader: "ui-icon-triangle-1-s",
1575 header: "ui-icon-triangle-1-e"
1576 },
1577
1578 // callbacks
1579 activate: null,
1580 beforeActivate: null
1581 },
1582
1583 hideProps: {
1584 borderTopWidth: "hide",
1585 borderBottomWidth: "hide",
1586 paddingTop: "hide",
1587 paddingBottom: "hide",
1588 height: "hide"
1589 },
1590
1591 showProps: {
1592 borderTopWidth: "show",
1593 borderBottomWidth: "show",
1594 paddingTop: "show",
1595 paddingBottom: "show",
1596 height: "show"
1597 },
1598
1599 _create: function() {
1600 var options = this.options;
1601 this.prevShow = this.prevHide = $();
1602 this.element.addClass( "ui-accordion ui-widget ui-helper-reset" )
1603 // ARIA
1604 .attr( "role", "tablist" );
1605
1606 // don't allow collapsible: false and active: false / null
1607 if ( !options.collapsible && (options.active === false || options.active == null) ) {
1608 options.active = 0;
1609 }
1610
1611 this._processPanels();
1612 // handle negative values
1613 if ( options.active < 0 ) {
1614 options.active += this.headers.length;
1615 }
1616 this._refresh();
1617 },
1618
1619 _getCreateEventData: function() {
1620 return {
1621 header: this.active,
1622 panel: !this.active.length ? $() : this.active.next()
1623 };
1624 },
1625
1626 _createIcons: function() {
1627 var icons = this.options.icons;
1628 if ( icons ) {
1629 $( "<span>" )
1630 .addClass( "ui-accordion-header-icon ui-icon " + icons.header )
1631 .prependTo( this.headers );
1632 this.active.children( ".ui-accordion-header-icon" )
1633 .removeClass( icons.header )
1634 .addClass( icons.activeHeader );
1635 this.headers.addClass( "ui-accordion-icons" );
1636 }
1637 },
1638
1639 _destroyIcons: function() {
1640 this.headers
1641 .removeClass( "ui-accordion-icons" )
1642 .children( ".ui-accordion-header-icon" )
1643 .remove();
1644 },
1645
1646 _destroy: function() {
1647 var contents;
1648
1649 // clean up main element
1650 this.element
1651 .removeClass( "ui-accordion ui-widget ui-helper-reset" )
1652 .removeAttr( "role" );
1653
1654 // clean up headers
1655 this.headers
1656 .removeClass( "ui-accordion-header ui-accordion-header-active ui-state-default " +
1657 "ui-corner-all ui-state-active ui-state-disabled ui-corner-top" )
1658 .removeAttr( "role" )
1659 .removeAttr( "aria-expanded" )
1660 .removeAttr( "aria-selected" )
1661 .removeAttr( "aria-controls" )
1662 .removeAttr( "tabIndex" )
1663 .removeUniqueId();
1664
1665 this._destroyIcons();
1666
1667 // clean up content panels
1668 contents = this.headers.next()
1669 .removeClass( "ui-helper-reset ui-widget-content ui-corner-bottom " +
1670 "ui-accordion-content ui-accordion-content-active ui-state-disabled" )
1671 .css( "display", "" )
1672 .removeAttr( "role" )
1673 .removeAttr( "aria-hidden" )
1674 .removeAttr( "aria-labelledby" )
1675 .removeUniqueId();
1676
1677 if ( this.options.heightStyle !== "content" ) {
1678 contents.css( "height", "" );
1679 }
1680 },
1681
1682 _setOption: function( key, value ) {
1683 if ( key === "active" ) {
1684 // _activate() will handle invalid values and update this.options
1685 this._activate( value );
1686 return;
1687 }
1688
1689 if ( key === "event" ) {
1690 if ( this.options.event ) {
1691 this._off( this.headers, this.options.event );
1692 }
1693 this._setupEvents( value );
1694 }
1695
1696 this._super( key, value );
1697
1698 // setting collapsible: false while collapsed; open first panel
1699 if ( key === "collapsible" && !value && this.options.active === false ) {
1700 this._activate( 0 );
1701 }
1702
1703 if ( key === "icons" ) {
1704 this._destroyIcons();
1705 if ( value ) {
1706 this._createIcons();
1707 }
1708 }
1709
1710 // #5332 - opacity doesn't cascade to positioned elements in IE
1711 // so we need to add the disabled class to the headers and panels
1712 if ( key === "disabled" ) {
1713 this.element
1714 .toggleClass( "ui-state-disabled", !!value )
1715 .attr( "aria-disabled", value );
1716 this.headers.add( this.headers.next() )
1717 .toggleClass( "ui-state-disabled", !!value );
1718 }
1719 },
1720
1721 _keydown: function( event ) {
1722 if ( event.altKey || event.ctrlKey ) {
1723 return;
1724 }
1725
1726 var keyCode = $.ui.keyCode,
1727 length = this.headers.length,
1728 currentIndex = this.headers.index( event.target ),
1729 toFocus = false;
1730
1731 switch ( event.keyCode ) {
1732 case keyCode.RIGHT:
1733 case keyCode.DOWN:
1734 toFocus = this.headers[ ( currentIndex + 1 ) % length ];
1735 break;
1736 case keyCode.LEFT:
1737 case keyCode.UP:
1738 toFocus = this.headers[ ( currentIndex - 1 + length ) % length ];
1739 break;
1740 case keyCode.SPACE:
1741 case keyCode.ENTER:
1742 this._eventHandler( event );
1743 break;
1744 case keyCode.HOME:
1745 toFocus = this.headers[ 0 ];
1746 break;
1747 case keyCode.END:
1748 toFocus = this.headers[ length - 1 ];
1749 break;
1750 }
1751
1752 if ( toFocus ) {
1753 $( event.target ).attr( "tabIndex", -1 );
1754 $( toFocus ).attr( "tabIndex", 0 );
1755 toFocus.focus();
1756 event.preventDefault();
1757 }
1758 },
1759
1760 _panelKeyDown: function( event ) {
1761 if ( event.keyCode === $.ui.keyCode.UP && event.ctrlKey ) {
1762 $( event.currentTarget ).prev().focus();
1763 }
1764 },
1765
1766 refresh: function() {
1767 var options = this.options;
1768 this._processPanels();
1769
1770 // was collapsed or no panel
1771 if ( ( options.active === false && options.collapsible === true ) || !this.headers.length ) {
1772 options.active = false;
1773 this.active = $();
1774 // active false only when collapsible is true
1775 } else if ( options.active === false ) {
1776 this._activate( 0 );
1777 // was active, but active panel is gone
1778 } else if ( this.active.length && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
1779 // all remaining panel are disabled
1780 if ( this.headers.length === this.headers.find(".ui-state-disabled").length ) {
1781 options.active = false;
1782 this.active = $();
1783 // activate previous panel
1784 } else {
1785 this._activate( Math.max( 0, options.active - 1 ) );
1786 }
1787 // was active, active panel still exists
1788 } else {
1789 // make sure active index is correct
1790 options.active = this.headers.index( this.active );
1791 }
1792
1793 this._destroyIcons();
1794
1795 this._refresh();
1796 },
1797
1798 _processPanels: function() {
1799 var prevHeaders = this.headers,
1800 prevPanels = this.panels;
1801
1802 this.headers = this.element.find( this.options.header )
1803 .addClass( "ui-accordion-header ui-state-default ui-corner-all" );
1804
1805 this.panels = this.headers.next()
1806 .addClass( "ui-accordion-content ui-helper-reset ui-widget-content ui-corner-bottom" )
1807 .filter( ":not(.ui-accordion-content-active)" )
1808 .hide();
1809
1810 // Avoid memory leaks (#10056)
1811 if ( prevPanels ) {
1812 this._off( prevHeaders.not( this.headers ) );
1813 this._off( prevPanels.not( this.panels ) );
1814 }
1815 },
1816
1817 _refresh: function() {
1818 var maxHeight,
1819 options = this.options,
1820 heightStyle = options.heightStyle,
1821 parent = this.element.parent();
1822
1823 this.active = this._findActive( options.active )
1824 .addClass( "ui-accordion-header-active ui-state-active ui-corner-top" )
1825 .removeClass( "ui-corner-all" );
1826 this.active.next()
1827 .addClass( "ui-accordion-content-active" )
1828 .show();
1829
1830 this.headers
1831 .attr( "role", "tab" )
1832 .each(function() {
1833 var header = $( this ),
1834 headerId = header.uniqueId().attr( "id" ),
1835 panel = header.next(),
1836 panelId = panel.uniqueId().attr( "id" );
1837 header.attr( "aria-controls", panelId );
1838 panel.attr( "aria-labelledby", headerId );
1839 })
1840 .next()
1841 .attr( "role", "tabpanel" );
1842
1843 this.headers
1844 .not( this.active )
1845 .attr({
1846 "aria-selected": "false",
1847 "aria-expanded": "false",
1848 tabIndex: -1
1849 })
1850 .next()
1851 .attr({
1852 "aria-hidden": "true"
1853 })
1854 .hide();
1855
1856 // make sure at least one header is in the tab order
1857 if ( !this.active.length ) {
1858 this.headers.eq( 0 ).attr( "tabIndex", 0 );
1859 } else {
1860 this.active.attr({
1861 "aria-selected": "true",
1862 "aria-expanded": "true",
1863 tabIndex: 0
1864 })
1865 .next()
1866 .attr({
1867 "aria-hidden": "false"
1868 });
1869 }
1870
1871 this._createIcons();
1872
1873 this._setupEvents( options.event );
1874
1875 if ( heightStyle === "fill" ) {
1876 maxHeight = parent.height();
1877 this.element.siblings( ":visible" ).each(function() {
1878 var elem = $( this ),
1879 position = elem.css( "position" );
1880
1881 if ( position === "absolute" || position === "fixed" ) {
1882 return;
1883 }
1884 maxHeight -= elem.outerHeight( true );
1885 });
1886
1887 this.headers.each(function() {
1888 maxHeight -= $( this ).outerHeight( true );
1889 });
1890
1891 this.headers.next()
1892 .each(function() {
1893 $( this ).height( Math.max( 0, maxHeight -
1894 $( this ).innerHeight() + $( this ).height() ) );
1895 })
1896 .css( "overflow", "auto" );
1897 } else if ( heightStyle === "auto" ) {
1898 maxHeight = 0;
1899 this.headers.next()
1900 .each(function() {
1901 maxHeight = Math.max( maxHeight, $( this ).css( "height", "" ).height() );
1902 })
1903 .height( maxHeight );
1904 }
1905 },
1906
1907 _activate: function( index ) {
1908 var active = this._findActive( index )[ 0 ];
1909
1910 // trying to activate the already active panel
1911 if ( active === this.active[ 0 ] ) {
1912 return;
1913 }
1914
1915 // trying to collapse, simulate a click on the currently active header
1916 active = active || this.active[ 0 ];
1917
1918 this._eventHandler({
1919 target: active,
1920 currentTarget: active,
1921 preventDefault: $.noop
1922 });
1923 },
1924
1925 _findActive: function( selector ) {
1926 return typeof selector === "number" ? this.headers.eq( selector ) : $();
1927 },
1928
1929 _setupEvents: function( event ) {
1930 var events = {
1931 keydown: "_keydown"
1932 };
1933 if ( event ) {
1934 $.each( event.split( " " ), function( index, eventName ) {
1935 events[ eventName ] = "_eventHandler";
1936 });
1937 }
1938
1939 this._off( this.headers.add( this.headers.next() ) );
1940 this._on( this.headers, events );
1941 this._on( this.headers.next(), { keydown: "_panelKeyDown" });
1942 this._hoverable( this.headers );
1943 this._focusable( this.headers );
1944 },
1945
1946 _eventHandler: function( event ) {
1947 var options = this.options,
1948 active = this.active,
1949 clicked = $( event.currentTarget ),
1950 clickedIsActive = clicked[ 0 ] === active[ 0 ],
1951 collapsing = clickedIsActive && options.collapsible,
1952 toShow = collapsing ? $() : clicked.next(),
1953 toHide = active.next(),
1954 eventData = {
1955 oldHeader: active,
1956 oldPanel: toHide,
1957 newHeader: collapsing ? $() : clicked,
1958 newPanel: toShow
1959 };
1960
1961 event.preventDefault();
1962
1963 if (
1964 // click on active header, but not collapsible
1965 ( clickedIsActive && !options.collapsible ) ||
1966 // allow canceling activation
1967 ( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
1968 return;
1969 }
1970
1971 options.active = collapsing ? false : this.headers.index( clicked );
1972
1973 // when the call to ._toggle() comes after the class changes
1974 // it causes a very odd bug in IE 8 (see #6720)
1975 this.active = clickedIsActive ? $() : clicked;
1976 this._toggle( eventData );
1977
1978 // switch classes
1979 // corner classes on the previously active header stay after the animation
1980 active.removeClass( "ui-accordion-header-active ui-state-active" );
1981 if ( options.icons ) {
1982 active.children( ".ui-accordion-header-icon" )
1983 .removeClass( options.icons.activeHeader )
1984 .addClass( options.icons.header );
1985 }
1986
1987 if ( !clickedIsActive ) {
1988 clicked
1989 .removeClass( "ui-corner-all" )
1990 .addClass( "ui-accordion-header-active ui-state-active ui-corner-top" );
1991 if ( options.icons ) {
1992 clicked.children( ".ui-accordion-header-icon" )
1993 .removeClass( options.icons.header )
1994 .addClass( options.icons.activeHeader );
1995 }
1996
1997 clicked
1998 .next()
1999 .addClass( "ui-accordion-content-active" );
2000 }
2001 },
2002
2003 _toggle: function( data ) {
2004 var toShow = data.newPanel,
2005 toHide = this.prevShow.length ? this.prevShow : data.oldPanel;
2006
2007 // handle activating a panel during the animation for another activation
2008 this.prevShow.add( this.prevHide ).stop( true, true );
2009 this.prevShow = toShow;
2010 this.prevHide = toHide;
2011
2012 if ( this.options.animate ) {
2013 this._animate( toShow, toHide, data );
2014 } else {
2015 toHide.hide();
2016 toShow.show();
2017 this._toggleComplete( data );
2018 }
2019
2020 toHide.attr({
2021 "aria-hidden": "true"
2022 });
2023 toHide.prev().attr({
2024 "aria-selected": "false",
2025 "aria-expanded": "false"
2026 });
2027 // if we're switching panels, remove the old header from the tab order
2028 // if we're opening from collapsed state, remove the previous header from the tab order
2029 // if we're collapsing, then keep the collapsing header in the tab order
2030 if ( toShow.length && toHide.length ) {
2031 toHide.prev().attr({
2032 "tabIndex": -1,
2033 "aria-expanded": "false"
2034 });
2035 } else if ( toShow.length ) {
2036 this.headers.filter(function() {
2037 return parseInt( $( this ).attr( "tabIndex" ), 10 ) === 0;
2038 })
2039 .attr( "tabIndex", -1 );
2040 }
2041
2042 toShow
2043 .attr( "aria-hidden", "false" )
2044 .prev()
2045 .attr({
2046 "aria-selected": "true",
2047 "aria-expanded": "true",
2048 tabIndex: 0
2049 });
2050 },
2051
2052 _animate: function( toShow, toHide, data ) {
2053 var total, easing, duration,
2054 that = this,
2055 adjust = 0,
2056 boxSizing = toShow.css( "box-sizing" ),
2057 down = toShow.length &&
2058 ( !toHide.length || ( toShow.index() < toHide.index() ) ),
2059 animate = this.options.animate || {},
2060 options = down && animate.down || animate,
2061 complete = function() {
2062 that._toggleComplete( data );
2063 };
2064
2065 if ( typeof options === "number" ) {
2066 duration = options;
2067 }
2068 if ( typeof options === "string" ) {
2069 easing = options;
2070 }
2071 // fall back from options to animation in case of partial down settings
2072 easing = easing || options.easing || animate.easing;
2073 duration = duration || options.duration || animate.duration;
2074
2075 if ( !toHide.length ) {
2076 return toShow.animate( this.showProps, duration, easing, complete );
2077 }
2078 if ( !toShow.length ) {
2079 return toHide.animate( this.hideProps, duration, easing, complete );
2080 }
2081
2082 total = toShow.show().outerHeight();
2083 toHide.animate( this.hideProps, {
2084 duration: duration,
2085 easing: easing,
2086 step: function( now, fx ) {
2087 fx.now = Math.round( now );
2088 }
2089 });
2090 toShow
2091 .hide()
2092 .animate( this.showProps, {
2093 duration: duration,
2094 easing: easing,
2095 complete: complete,
2096 step: function( now, fx ) {
2097 fx.now = Math.round( now );
2098 if ( fx.prop !== "height" ) {
2099 if ( boxSizing === "content-box" ) {
2100 adjust += fx.now;
2101 }
2102 } else if ( that.options.heightStyle !== "content" ) {
2103 fx.now = Math.round( total - toHide.outerHeight() - adjust );
2104 adjust = 0;
2105 }
2106 }
2107 });
2108 },
2109
2110 _toggleComplete: function( data ) {
2111 var toHide = data.oldPanel;
2112
2113 toHide
2114 .removeClass( "ui-accordion-content-active" )
2115 .prev()
2116 .removeClass( "ui-corner-top" )
2117 .addClass( "ui-corner-all" );
2118
2119 // Work around for rendering bug in IE (#5421)
2120 if ( toHide.length ) {
2121 toHide.parent()[ 0 ].className = toHide.parent()[ 0 ].className;
2122 }
2123 this._trigger( "activate", null, data );
2124 }
2125 });
2126
2127
2128 /*!
2129 * jQuery UI Menu 1.11.4
2130 * http://jqueryui.com
2131 *
2132 * Copyright jQuery Foundation and other contributors
2133 * Released under the MIT license.
2134 * http://jquery.org/license
2135 *
2136 * http://api.jqueryui.com/menu/
2137 */
2138
2139
2140 var menu = $.widget( "ui.menu", {
2141 version: "1.11.4",
2142 defaultElement: "<ul>",
2143 delay: 300,
2144 options: {
2145 icons: {
2146 submenu: "ui-icon-carat-1-e"
2147 },
2148 items: "> *",
2149 menus: "ul",
2150 position: {
2151 my: "left-1 top",
2152 at: "right top"
2153 },
2154 role: "menu",
2155
2156 // callbacks
2157 blur: null,
2158 focus: null,
2159 select: null
2160 },
2161
2162 _create: function() {
2163 this.activeMenu = this.element;
2164
2165 // Flag used to prevent firing of the click handler
2166 // as the event bubbles up through nested menus
2167 this.mouseHandled = false;
2168 this.element
2169 .uniqueId()
2170 .addClass( "ui-menu ui-widget ui-widget-content" )
2171 .toggleClass( "ui-menu-icons", !!this.element.find( ".ui-icon" ).length )
2172 .attr({
2173 role: this.options.role,
2174 tabIndex: 0
2175 });
2176
2177 if ( this.options.disabled ) {
2178 this.element
2179 .addClass( "ui-state-disabled" )
2180 .attr( "aria-disabled", "true" );
2181 }
2182
2183 this._on({
2184 // Prevent focus from sticking to links inside menu after clicking
2185 // them (focus should always stay on UL during navigation).
2186 "mousedown .ui-menu-item": function( event ) {
2187 event.preventDefault();
2188 },
2189 "click .ui-menu-item": function( event ) {
2190 var target = $( event.target );
2191 if ( !this.mouseHandled && target.not( ".ui-state-disabled" ).length ) {
2192 this.select( event );
2193
2194 // Only set the mouseHandled flag if the event will bubble, see #9469.
2195 if ( !event.isPropagationStopped() ) {
2196 this.mouseHandled = true;
2197 }
2198
2199 // Open submenu on click
2200 if ( target.has( ".ui-menu" ).length ) {
2201 this.expand( event );
2202 } else if ( !this.element.is( ":focus" ) && $( this.document[ 0 ].activeElement ).closest( ".ui-menu" ).length ) {
2203
2204 // Redirect focus to the menu
2205 this.element.trigger( "focus", [ true ] );
2206
2207 // If the active item is on the top level, let it stay active.
2208 // Otherwise, blur the active item since it is no longer visible.
2209 if ( this.active && this.active.parents( ".ui-menu" ).length === 1 ) {
2210 clearTimeout( this.timer );
2211 }
2212 }
2213 }
2214 },
2215 "mouseenter .ui-menu-item": function( event ) {
2216 // Ignore mouse events while typeahead is active, see #10458.
2217 // Prevents focusing the wrong item when typeahead causes a scroll while the mouse
2218 // is over an item in the menu
2219 if ( this.previousFilter ) {
2220 return;
2221 }
2222 var target = $( event.currentTarget );
2223 // Remove ui-state-active class from siblings of the newly focused menu item
2224 // to avoid a jump caused by adjacent elements both having a class with a border
2225 target.siblings( ".ui-state-active" ).removeClass( "ui-state-active" );
2226 this.focus( event, target );
2227 },
2228 mouseleave: "collapseAll",
2229 "mouseleave .ui-menu": "collapseAll",
2230 focus: function( event, keepActiveItem ) {
2231 // If there's already an active item, keep it active
2232 // If not, activate the first item
2233 var item = this.active || this.element.find( this.options.items ).eq( 0 );
2234
2235 if ( !keepActiveItem ) {
2236 this.focus( event, item );
2237 }
2238 },
2239 blur: function( event ) {
2240 this._delay(function() {
2241 if ( !$.contains( this.element[0], this.document[0].activeElement ) ) {
2242 this.collapseAll( event );
2243 }
2244 });
2245 },
2246 keydown: "_keydown"
2247 });
2248
2249 this.refresh();
2250
2251 // Clicks outside of a menu collapse any open menus
2252 this._on( this.document, {
2253 click: function( event ) {
2254 if ( this._closeOnDocumentClick( event ) ) {
2255 this.collapseAll( event );
2256 }
2257
2258 // Reset the mouseHandled flag
2259 this.mouseHandled = false;
2260 }
2261 });
2262 },
2263
2264 _destroy: function() {
2265 // Destroy (sub)menus
2266 this.element
2267 .removeAttr( "aria-activedescendant" )
2268 .find( ".ui-menu" ).addBack()
2269 .removeClass( "ui-menu ui-widget ui-widget-content ui-menu-icons ui-front" )
2270 .removeAttr( "role" )
2271 .removeAttr( "tabIndex" )
2272 .removeAttr( "aria-labelledby" )
2273 .removeAttr( "aria-expanded" )
2274 .removeAttr( "aria-hidden" )
2275 .removeAttr( "aria-disabled" )
2276 .removeUniqueId()
2277 .show();
2278
2279 // Destroy menu items
2280 this.element.find( ".ui-menu-item" )
2281 .removeClass( "ui-menu-item" )
2282 .removeAttr( "role" )
2283 .removeAttr( "aria-disabled" )
2284 .removeUniqueId()
2285 .removeClass( "ui-state-hover" )
2286 .removeAttr( "tabIndex" )
2287 .removeAttr( "role" )
2288 .removeAttr( "aria-haspopup" )
2289 .children().each( function() {
2290 var elem = $( this );
2291 if ( elem.data( "ui-menu-submenu-carat" ) ) {
2292 elem.remove();
2293 }
2294 });
2295
2296 // Destroy menu dividers
2297 this.element.find( ".ui-menu-divider" ).removeClass( "ui-menu-divider ui-widget-content" );
2298 },
2299
2300 _keydown: function( event ) {
2301 var match, prev, character, skip,
2302 preventDefault = true;
2303
2304 switch ( event.keyCode ) {
2305 case $.ui.keyCode.PAGE_UP:
2306 this.previousPage( event );
2307 break;
2308 case $.ui.keyCode.PAGE_DOWN:
2309 this.nextPage( event );
2310 break;
2311 case $.ui.keyCode.HOME:
2312 this._move( "first", "first", event );
2313 break;
2314 case $.ui.keyCode.END:
2315 this._move( "last", "last", event );
2316 break;
2317 case $.ui.keyCode.UP:
2318 this.previous( event );
2319 break;
2320 case $.ui.keyCode.DOWN:
2321 this.next( event );
2322 break;
2323 case $.ui.keyCode.LEFT:
2324 this.collapse( event );
2325 break;
2326 case $.ui.keyCode.RIGHT:
2327 if ( this.active && !this.active.is( ".ui-state-disabled" ) ) {
2328 this.expand( event );
2329 }
2330 break;
2331 case $.ui.keyCode.ENTER:
2332 case $.ui.keyCode.SPACE:
2333 this._activate( event );
2334 break;
2335 case $.ui.keyCode.ESCAPE:
2336 this.collapse( event );
2337 break;
2338 default:
2339 preventDefault = false;
2340 prev = this.previousFilter || "";
2341 character = String.fromCharCode( event.keyCode );
2342 skip = false;
2343
2344 clearTimeout( this.filterTimer );
2345
2346 if ( character === prev ) {
2347 skip = true;
2348 } else {
2349 character = prev + character;
2350 }
2351
2352 match = this._filterMenuItems( character );
2353 match = skip && match.index( this.active.next() ) !== -1 ?
2354 this.active.nextAll( ".ui-menu-item" ) :
2355 match;
2356
2357 // If no matches on the current filter, reset to the last character pressed
2358 // to move down the menu to the first item that starts with that character
2359 if ( !match.length ) {
2360 character = String.fromCharCode( event.keyCode );
2361 match = this._filterMenuItems( character );
2362 }
2363
2364 if ( match.length ) {
2365 this.focus( event, match );
2366 this.previousFilter = character;
2367 this.filterTimer = this._delay(function() {
2368 delete this.previousFilter;
2369 }, 1000 );
2370 } else {
2371 delete this.previousFilter;
2372 }
2373 }
2374
2375 if ( preventDefault ) {
2376 event.preventDefault();
2377 }
2378 },
2379
2380 _activate: function( event ) {
2381 if ( !this.active.is( ".ui-state-disabled" ) ) {
2382 if ( this.active.is( "[aria-haspopup='true']" ) ) {
2383 this.expand( event );
2384 } else {
2385 this.select( event );
2386 }
2387 }
2388 },
2389
2390 refresh: function() {
2391 var menus, items,
2392 that = this,
2393 icon = this.options.icons.submenu,
2394 submenus = this.element.find( this.options.menus );
2395
2396 this.element.toggleClass( "ui-menu-icons", !!this.element.find( ".ui-icon" ).length );
2397
2398 // Initialize nested menus
2399 submenus.filter( ":not(.ui-menu)" )
2400 .addClass( "ui-menu ui-widget ui-widget-content ui-front" )
2401 .hide()
2402 .attr({
2403 role: this.options.role,
2404 "aria-hidden": "true",
2405 "aria-expanded": "false"
2406 })
2407 .each(function() {
2408 var menu = $( this ),
2409 item = menu.parent(),
2410 submenuCarat = $( "<span>" )
2411 .addClass( "ui-menu-icon ui-icon " + icon )
2412 .data( "ui-menu-submenu-carat", true );
2413
2414 item
2415 .attr( "aria-haspopup", "true" )
2416 .prepend( submenuCarat );
2417 menu.attr( "aria-labelledby", item.attr( "id" ) );
2418 });
2419
2420 menus = submenus.add( this.element );
2421 items = menus.find( this.options.items );
2422
2423 // Initialize menu-items containing spaces and/or dashes only as dividers
2424 items.not( ".ui-menu-item" ).each(function() {
2425 var item = $( this );
2426 if ( that._isDivider( item ) ) {
2427 item.addClass( "ui-widget-content ui-menu-divider" );
2428 }
2429 });
2430
2431 // Don't refresh list items that are already adapted
2432 items.not( ".ui-menu-item, .ui-menu-divider" )
2433 .addClass( "ui-menu-item" )
2434 .uniqueId()
2435 .attr({
2436 tabIndex: -1,
2437 role: this._itemRole()
2438 });
2439
2440 // Add aria-disabled attribute to any disabled menu item
2441 items.filter( ".ui-state-disabled" ).attr( "aria-disabled", "true" );
2442
2443 // If the active item has been removed, blur the menu
2444 if ( this.active && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
2445 this.blur();
2446 }
2447 },
2448
2449 _itemRole: function() {
2450 return {
2451 menu: "menuitem",
2452 listbox: "option"
2453 }[ this.options.role ];
2454 },
2455
2456 _setOption: function( key, value ) {
2457 if ( key === "icons" ) {
2458 this.element.find( ".ui-menu-icon" )
2459 .removeClass( this.options.icons.submenu )
2460 .addClass( value.submenu );
2461 }
2462 if ( key === "disabled" ) {
2463 this.element
2464 .toggleClass( "ui-state-disabled", !!value )
2465 .attr( "aria-disabled", value );
2466 }
2467 this._super( key, value );
2468 },
2469
2470 focus: function( event, item ) {
2471 var nested, focused;
2472 this.blur( event, event && event.type === "focus" );
2473
2474 this._scrollIntoView( item );
2475
2476 this.active = item.first();
2477 focused = this.active.addClass( "ui-state-focus" ).removeClass( "ui-state-active" );
2478 // Only update aria-activedescendant if there's a role
2479 // otherwise we assume focus is managed elsewhere
2480 if ( this.options.role ) {
2481 this.element.attr( "aria-activedescendant", focused.attr( "id" ) );
2482 }
2483
2484 // Highlight active parent menu item, if any
2485 this.active
2486 .parent()
2487 .closest( ".ui-menu-item" )
2488 .addClass( "ui-state-active" );
2489
2490 if ( event && event.type === "keydown" ) {
2491 this._close();
2492 } else {
2493 this.timer = this._delay(function() {
2494 this._close();
2495 }, this.delay );
2496 }
2497
2498 nested = item.children( ".ui-menu" );
2499 if ( nested.length && event && ( /^mouse/.test( event.type ) ) ) {
2500 this._startOpening(nested);
2501 }
2502 this.activeMenu = item.parent();
2503
2504 this._trigger( "focus", event, { item: item } );
2505 },
2506
2507 _scrollIntoView: function( item ) {
2508 var borderTop, paddingTop, offset, scroll, elementHeight, itemHeight;
2509 if ( this._hasScroll() ) {
2510 borderTop = parseFloat( $.css( this.activeMenu[0], "borderTopWidth" ) ) || 0;
2511 paddingTop = parseFloat( $.css( this.activeMenu[0], "paddingTop" ) ) || 0;
2512 offset = item.offset().top - this.activeMenu.offset().top - borderTop - paddingTop;
2513 scroll = this.activeMenu.scrollTop();
2514 elementHeight = this.activeMenu.height();
2515 itemHeight = item.outerHeight();
2516
2517 if ( offset < 0 ) {
2518 this.activeMenu.scrollTop( scroll + offset );
2519 } else if ( offset + itemHeight > elementHeight ) {
2520 this.activeMenu.scrollTop( scroll + offset - elementHeight + itemHeight );
2521 }
2522 }
2523 },
2524
2525 blur: function( event, fromFocus ) {
2526 if ( !fromFocus ) {
2527 clearTimeout( this.timer );
2528 }
2529
2530 if ( !this.active ) {
2531 return;
2532 }
2533
2534 this.active.removeClass( "ui-state-focus" );
2535 this.active = null;
2536
2537 this._trigger( "blur", event, { item: this.active } );
2538 },
2539
2540 _startOpening: function( submenu ) {
2541 clearTimeout( this.timer );
2542
2543 // Don't open if already open fixes a Firefox bug that caused a .5 pixel
2544 // shift in the submenu position when mousing over the carat icon
2545 if ( submenu.attr( "aria-hidden" ) !== "true" ) {
2546 return;
2547 }
2548
2549 this.timer = this._delay(function() {
2550 this._close();
2551 this._open( submenu );
2552 }, this.delay );
2553 },
2554
2555 _open: function( submenu ) {
2556 var position = $.extend({
2557 of: this.active
2558 }, this.options.position );
2559
2560 clearTimeout( this.timer );
2561 this.element.find( ".ui-menu" ).not( submenu.parents( ".ui-menu" ) )
2562 .hide()
2563 .attr( "aria-hidden", "true" );
2564
2565 submenu
2566 .show()
2567 .removeAttr( "aria-hidden" )
2568 .attr( "aria-expanded", "true" )
2569 .position( position );
2570 },
2571
2572 collapseAll: function( event, all ) {
2573 clearTimeout( this.timer );
2574 this.timer = this._delay(function() {
2575 // If we were passed an event, look for the submenu that contains the event
2576 var currentMenu = all ? this.element :
2577 $( event && event.target ).closest( this.element.find( ".ui-menu" ) );
2578
2579 // If we found no valid submenu ancestor, use the main menu to close all sub menus anyway
2580 if ( !currentMenu.length ) {
2581 currentMenu = this.element;
2582 }
2583
2584 this._close( currentMenu );
2585
2586 this.blur( event );
2587 this.activeMenu = currentMenu;
2588 }, this.delay );
2589 },
2590
2591 // With no arguments, closes the currently active menu - if nothing is active
2592 // it closes all menus. If passed an argument, it will search for menus BELOW
2593 _close: function( startMenu ) {
2594 if ( !startMenu ) {
2595 startMenu = this.active ? this.active.parent() : this.element;
2596 }
2597
2598 startMenu
2599 .find( ".ui-menu" )
2600 .hide()
2601 .attr( "aria-hidden", "true" )
2602 .attr( "aria-expanded", "false" )
2603 .end()
2604 .find( ".ui-state-active" ).not( ".ui-state-focus" )
2605 .removeClass( "ui-state-active" );
2606 },
2607
2608 _closeOnDocumentClick: function( event ) {
2609 return !$( event.target ).closest( ".ui-menu" ).length;
2610 },
2611
2612 _isDivider: function( item ) {
2613
2614 // Match hyphen, em dash, en dash
2615 return !/[^\-\u2014\u2013\s]/.test( item.text() );
2616 },
2617
2618 collapse: function( event ) {
2619 var newItem = this.active &&
2620 this.active.parent().closest( ".ui-menu-item", this.element );
2621 if ( newItem && newItem.length ) {
2622 this._close();
2623 this.focus( event, newItem );
2624 }
2625 },
2626
2627 expand: function( event ) {
2628 var newItem = this.active &&
2629 this.active
2630 .children( ".ui-menu " )
2631 .find( this.options.items )
2632 .first();
2633
2634 if ( newItem && newItem.length ) {
2635 this._open( newItem.parent() );
2636
2637 // Delay so Firefox will not hide activedescendant change in expanding submenu from AT
2638 this._delay(function() {
2639 this.focus( event, newItem );
2640 });
2641 }
2642 },
2643
2644 next: function( event ) {
2645 this._move( "next", "first", event );
2646 },
2647
2648 previous: function( event ) {
2649 this._move( "prev", "last", event );
2650 },
2651
2652 isFirstItem: function() {
2653 return this.active && !this.active.prevAll( ".ui-menu-item" ).length;
2654 },
2655
2656 isLastItem: function() {
2657 return this.active && !this.active.nextAll( ".ui-menu-item" ).length;
2658 },
2659
2660 _move: function( direction, filter, event ) {
2661 var next;
2662 if ( this.active ) {
2663 if ( direction === "first" || direction === "last" ) {
2664 next = this.active
2665 [ direction === "first" ? "prevAll" : "nextAll" ]( ".ui-menu-item" )
2666 .eq( -1 );
2667 } else {
2668 next = this.active
2669 [ direction + "All" ]( ".ui-menu-item" )
2670 .eq( 0 );
2671 }
2672 }
2673 if ( !next || !next.length || !this.active ) {
2674 next = this.activeMenu.find( this.options.items )[ filter ]();
2675 }
2676
2677 this.focus( event, next );
2678 },
2679
2680 nextPage: function( event ) {
2681 var item, base, height;
2682
2683 if ( !this.active ) {
2684 this.next( event );
2685 return;
2686 }
2687 if ( this.isLastItem() ) {
2688 return;
2689 }
2690 if ( this._hasScroll() ) {
2691 base = this.active.offset().top;
2692 height = this.element.height();
2693 this.active.nextAll( ".ui-menu-item" ).each(function() {
2694 item = $( this );
2695 return item.offset().top - base - height < 0;
2696 });
2697
2698 this.focus( event, item );
2699 } else {
2700 this.focus( event, this.activeMenu.find( this.options.items )
2701 [ !this.active ? "first" : "last" ]() );
2702 }
2703 },
2704
2705 previousPage: function( event ) {
2706 var item, base, height;
2707 if ( !this.active ) {
2708 this.next( event );
2709 return;
2710 }
2711 if ( this.isFirstItem() ) {
2712 return;
2713 }
2714 if ( this._hasScroll() ) {
2715 base = this.active.offset().top;
2716 height = this.element.height();
2717 this.active.prevAll( ".ui-menu-item" ).each(function() {
2718 item = $( this );
2719 return item.offset().top - base + height > 0;
2720 });
2721
2722 this.focus( event, item );
2723 } else {
2724 this.focus( event, this.activeMenu.find( this.options.items ).first() );
2725 }
2726 },
2727
2728 _hasScroll: function() {
2729 return this.element.outerHeight() < this.element.prop( "scrollHeight" );
2730 },
2731
2732 select: function( event ) {
2733 // TODO: It should never be possible to not have an active item at this
2734 // point, but the tests don't trigger mouseenter before click.
2735 this.active = this.active || $( event.target ).closest( ".ui-menu-item" );
2736 var ui = { item: this.active };
2737 if ( !this.active.has( ".ui-menu" ).length ) {
2738 this.collapseAll( event, true );
2739 }
2740 this._trigger( "select", event, ui );
2741 },
2742
2743 _filterMenuItems: function(character) {
2744 var escapedCharacter = character.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" ),
2745 regex = new RegExp( "^" + escapedCharacter, "i" );
2746
2747 return this.activeMenu
2748 .find( this.options.items )
2749
2750 // Only match on items, not dividers or other content (#10571)
2751 .filter( ".ui-menu-item" )
2752 .filter(function() {
2753 return regex.test( $.trim( $( this ).text() ) );
2754 });
2755 }
2756 });
2757
2758
2759 /*!
2760 * jQuery UI Autocomplete 1.11.4
2761 * http://jqueryui.com
2762 *
2763 * Copyright jQuery Foundation and other contributors
2764 * Released under the MIT license.
2765 * http://jquery.org/license
2766 *
2767 * http://api.jqueryui.com/autocomplete/
2768 */
2769
2770
2771 $.widget( "ui.autocomplete", {
2772 version: "1.11.4",
2773 defaultElement: "<input>",
2774 options: {
2775 appendTo: null,
2776 autoFocus: false,
2777 delay: 300,
2778 minLength: 1,
2779 position: {
2780 my: "left top",
2781 at: "left bottom",
2782 collision: "none"
2783 },
2784 source: null,
2785
2786 // callbacks
2787 change: null,
2788 close: null,
2789 focus: null,
2790 open: null,
2791 response: null,
2792 search: null,
2793 select: null
2794 },
2795
2796 requestIndex: 0,
2797 pending: 0,
2798
2799 _create: function() {
2800 // Some browsers only repeat keydown events, not keypress events,
2801 // so we use the suppressKeyPress flag to determine if we've already
2802 // handled the keydown event. #7269
2803 // Unfortunately the code for & in keypress is the same as the up arrow,
2804 // so we use the suppressKeyPressRepeat flag to avoid handling keypress
2805 // events when we know the keydown event was used to modify the
2806 // search term. #7799
2807 var suppressKeyPress, suppressKeyPressRepeat, suppressInput,
2808 nodeName = this.element[ 0 ].nodeName.toLowerCase(),
2809 isTextarea = nodeName === "textarea",
2810 isInput = nodeName === "input";
2811
2812 this.isMultiLine =
2813 // Textareas are always multi-line
2814 isTextarea ? true :
2815 // Inputs are always single-line, even if inside a contentEditable element
2816 // IE also treats inputs as contentEditable
2817 isInput ? false :
2818 // All other element types are determined by whether or not they're contentEditable
2819 this.element.prop( "isContentEditable" );
2820
2821 this.valueMethod = this.element[ isTextarea || isInput ? "val" : "text" ];
2822 this.isNewMenu = true;
2823
2824 this.element
2825 .addClass( "ui-autocomplete-input" )
2826 .attr( "autocomplete", "off" );
2827
2828 this._on( this.element, {
2829 keydown: function( event ) {
2830 if ( this.element.prop( "readOnly" ) ) {
2831 suppressKeyPress = true;
2832 suppressInput = true;
2833 suppressKeyPressRepeat = true;
2834 return;
2835 }
2836
2837 suppressKeyPress = false;
2838 suppressInput = false;
2839 suppressKeyPressRepeat = false;
2840 var keyCode = $.ui.keyCode;
2841 switch ( event.keyCode ) {
2842 case keyCode.PAGE_UP:
2843 suppressKeyPress = true;
2844 this._move( "previousPage", event );
2845 break;
2846 case keyCode.PAGE_DOWN:
2847 suppressKeyPress = true;
2848 this._move( "nextPage", event );
2849 break;
2850 case keyCode.UP:
2851 suppressKeyPress = true;
2852 this._keyEvent( "previous", event );
2853 break;
2854 case keyCode.DOWN:
2855 suppressKeyPress = true;
2856 this._keyEvent( "next", event );
2857 break;
2858 case keyCode.ENTER:
2859 // when menu is open and has focus
2860 if ( this.menu.active ) {
2861 // #6055 - Opera still allows the keypress to occur
2862 // which causes forms to submit
2863 suppressKeyPress = true;
2864 event.preventDefault();
2865 this.menu.select( event );
2866 }
2867 break;
2868 case keyCode.TAB:
2869 if ( this.menu.active ) {
2870 this.menu.select( event );
2871 }
2872 break;
2873 case keyCode.ESCAPE:
2874 if ( this.menu.element.is( ":visible" ) ) {
2875 if ( !this.isMultiLine ) {
2876 this._value( this.term );
2877 }
2878 this.close( event );
2879 // Different browsers have different default behavior for escape
2880 // Single press can mean undo or clear
2881 // Double press in IE means clear the whole form
2882 event.preventDefault();
2883 }
2884 break;
2885 default:
2886 suppressKeyPressRepeat = true;
2887 // search timeout should be triggered before the input value is changed
2888 this._searchTimeout( event );
2889 break;
2890 }
2891 },
2892 keypress: function( event ) {
2893 if ( suppressKeyPress ) {
2894 suppressKeyPress = false;
2895 if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
2896 event.preventDefault();
2897 }
2898 return;
2899 }
2900 if ( suppressKeyPressRepeat ) {
2901 return;
2902 }
2903
2904 // replicate some key handlers to allow them to repeat in Firefox and Opera
2905 var keyCode = $.ui.keyCode;
2906 switch ( event.keyCode ) {
2907 case keyCode.PAGE_UP:
2908 this._move( "previousPage", event );
2909 break;
2910 case keyCode.PAGE_DOWN:
2911 this._move( "nextPage", event );
2912 break;
2913 case keyCode.UP:
2914 this._keyEvent( "previous", event );
2915 break;
2916 case keyCode.DOWN:
2917 this._keyEvent( "next", event );
2918 break;
2919 }
2920 },
2921 input: function( event ) {
2922 if ( suppressInput ) {
2923 suppressInput = false;
2924 event.preventDefault();
2925 return;
2926 }
2927 this._searchTimeout( event );
2928 },
2929 focus: function() {
2930 this.selectedItem = null;
2931 this.previous = this._value();
2932 },
2933 blur: function( event ) {
2934 if ( this.cancelBlur ) {
2935 delete this.cancelBlur;
2936 return;
2937 }
2938
2939 clearTimeout( this.searching );
2940 this.close( event );
2941 this._change( event );
2942 }
2943 });
2944
2945 this._initSource();
2946 this.menu = $( "<ul>" )
2947 .addClass( "ui-autocomplete ui-front" )
2948 .appendTo( this._appendTo() )
2949 .menu({
2950 // disable ARIA support, the live region takes care of that
2951 role: null
2952 })
2953 .hide()
2954 .menu( "instance" );
2955
2956 this._on( this.menu.element, {
2957 mousedown: function( event ) {
2958 // prevent moving focus out of the text field
2959 event.preventDefault();
2960
2961 // IE doesn't prevent moving focus even with event.preventDefault()
2962 // so we set a flag to know when we should ignore the blur event
2963 this.cancelBlur = true;
2964 this._delay(function() {
2965 delete this.cancelBlur;
2966 });
2967
2968 // clicking on the scrollbar causes focus to shift to the body
2969 // but we can't detect a mouseup or a click immediately afterward
2970 // so we have to track the next mousedown and close the menu if
2971 // the user clicks somewhere outside of the autocomplete
2972 var menuElement = this.menu.element[ 0 ];
2973 if ( !$( event.target ).closest( ".ui-menu-item" ).length ) {
2974 this._delay(function() {
2975 var that = this;
2976 this.document.one( "mousedown", function( event ) {
2977 if ( event.target !== that.element[ 0 ] &&
2978 event.target !== menuElement &&
2979 !$.contains( menuElement, event.target ) ) {
2980 that.close();
2981 }
2982 });
2983 });
2984 }
2985 },
2986 menufocus: function( event, ui ) {
2987 var label, item;
2988 // support: Firefox
2989 // Prevent accidental activation of menu items in Firefox (#7024 #9118)
2990 if ( this.isNewMenu ) {
2991 this.isNewMenu = false;
2992 if ( event.originalEvent && /^mouse/.test( event.originalEvent.type ) ) {
2993 this.menu.blur();
2994
2995 this.document.one( "mousemove", function() {
2996 $( event.target ).trigger( event.originalEvent );
2997 });
2998
2999 return;
3000 }
3001 }
3002
3003 item = ui.item.data( "ui-autocomplete-item" );
3004 if ( false !== this._trigger( "focus", event, { item: item } ) ) {
3005 // use value to match what will end up in the input, if it was a key event
3006 if ( event.originalEvent && /^key/.test( event.originalEvent.type ) ) {
3007 this._value( item.value );
3008 }
3009 }
3010
3011 // Announce the value in the liveRegion
3012 label = ui.item.attr( "aria-label" ) || item.value;
3013 if ( label && $.trim( label ).length ) {
3014 this.liveRegion.children().hide();
3015 $( "<div>" ).text( label ).appendTo( this.liveRegion );
3016 }
3017 },
3018 menuselect: function( event, ui ) {
3019 var item = ui.item.data( "ui-autocomplete-item" ),
3020 previous = this.previous;
3021
3022 // only trigger when focus was lost (click on menu)
3023 if ( this.element[ 0 ] !== this.document[ 0 ].activeElement ) {
3024 this.element.focus();
3025 this.previous = previous;
3026 // #6109 - IE triggers two focus events and the second
3027 // is asynchronous, so we need to reset the previous
3028 // term synchronously and asynchronously :-(
3029 this._delay(function() {
3030 this.previous = previous;
3031 this.selectedItem = item;
3032 });
3033 }
3034
3035 if ( false !== this._trigger( "select", event, { item: item } ) ) {
3036 this._value( item.value );
3037 }
3038 // reset the term after the select event
3039 // this allows custom select handling to work properly
3040 this.term = this._value();
3041
3042 this.close( event );
3043 this.selectedItem = item;
3044 }
3045 });
3046
3047 this.liveRegion = $( "<span>", {
3048 role: "status",
3049 "aria-live": "assertive",
3050 "aria-relevant": "additions"
3051 })
3052 .addClass( "ui-helper-hidden-accessible" )
3053 .appendTo( this.document[ 0 ].body );
3054
3055 // turning off autocomplete prevents the browser from remembering the
3056 // value when navigating through history, so we re-enable autocomplete
3057 // if the page is unloaded before the widget is destroyed. #7790
3058 this._on( this.window, {
3059 beforeunload: function() {
3060 this.element.removeAttr( "autocomplete" );
3061 }
3062 });
3063 },
3064
3065 _destroy: function() {
3066 clearTimeout( this.searching );
3067 this.element
3068 .removeClass( "ui-autocomplete-input" )
3069 .removeAttr( "autocomplete" );
3070 this.menu.element.remove();
3071 this.liveRegion.remove();
3072 },
3073
3074 _setOption: function( key, value ) {
3075 this._super( key, value );
3076 if ( key === "source" ) {
3077 this._initSource();
3078 }
3079 if ( key === "appendTo" ) {
3080 this.menu.element.appendTo( this._appendTo() );
3081 }
3082 if ( key === "disabled" && value && this.xhr ) {
3083 this.xhr.abort();
3084 }
3085 },
3086
3087 _appendTo: function() {
3088 var element = this.options.appendTo;
3089
3090 if ( element ) {
3091 element = element.jquery || element.nodeType ?
3092 $( element ) :
3093 this.document.find( element ).eq( 0 );
3094 }
3095
3096 if ( !element || !element[ 0 ] ) {
3097 element = this.element.closest( ".ui-front" );
3098 }
3099
3100 if ( !element.length ) {
3101 element = this.document[ 0 ].body;
3102 }
3103
3104 return element;
3105 },
3106
3107 _initSource: function() {
3108 var array, url,
3109 that = this;
3110 if ( $.isArray( this.options.source ) ) {
3111 array = this.options.source;
3112 this.source = function( request, response ) {
3113 response( $.ui.autocomplete.filter( array, request.term ) );
3114 };
3115 } else if ( typeof this.options.source === "string" ) {
3116 url = this.options.source;
3117 this.source = function( request, response ) {
3118 if ( that.xhr ) {
3119 that.xhr.abort();
3120 }
3121 that.xhr = $.ajax({
3122 url: url,
3123 data: request,
3124 dataType: "json",
3125 success: function( data ) {
3126 response( data );
3127 },
3128 error: function() {
3129 response([]);
3130 }
3131 });
3132 };
3133 } else {
3134 this.source = this.options.source;
3135 }
3136 },
3137
3138 _searchTimeout: function( event ) {
3139 clearTimeout( this.searching );
3140 this.searching = this._delay(function() {
3141
3142 // Search if the value has changed, or if the user retypes the same value (see #7434)
3143 var equalValues = this.term === this._value(),
3144 menuVisible = this.menu.element.is( ":visible" ),
3145 modifierKey = event.altKey || event.ctrlKey || event.metaKey || event.shiftKey;
3146
3147 if ( !equalValues || ( equalValues && !menuVisible && !modifierKey ) ) {
3148 this.selectedItem = null;
3149 this.search( null, event );
3150 }
3151 }, this.options.delay );
3152 },
3153
3154 search: function( value, event ) {
3155 value = value != null ? value : this._value();
3156
3157 // always save the actual value, not the one passed as an argument
3158 this.term = this._value();
3159
3160 if ( value.length < this.options.minLength ) {
3161 return this.close( event );
3162 }
3163
3164 if ( this._trigger( "search", event ) === false ) {
3165 return;
3166 }
3167
3168 return this._search( value );
3169 },
3170
3171 _search: function( value ) {
3172 this.pending++;
3173 this.element.addClass( "ui-autocomplete-loading" );
3174 this.cancelSearch = false;
3175
3176 this.source( { term: value }, this._response() );
3177 },
3178
3179 _response: function() {
3180 var index = ++this.requestIndex;
3181
3182 return $.proxy(function( content ) {
3183 if ( index === this.requestIndex ) {
3184 this.__response( content );
3185 }
3186
3187 this.pending--;
3188 if ( !this.pending ) {
3189 this.element.removeClass( "ui-autocomplete-loading" );
3190 }
3191 }, this );
3192 },
3193
3194 __response: function( content ) {
3195 if ( content ) {
3196 content = this._normalize( content );
3197 }
3198 this._trigger( "response", null, { content: content } );
3199 if ( !this.options.disabled && content && content.length && !this.cancelSearch ) {
3200 this._suggest( content );
3201 this._trigger( "open" );
3202 } else {
3203 // use ._close() instead of .close() so we don't cancel future searches
3204 this._close();
3205 }
3206 },
3207
3208 close: function( event ) {
3209 this.cancelSearch = true;
3210 this._close( event );
3211 },
3212
3213 _close: function( event ) {
3214 if ( this.menu.element.is( ":visible" ) ) {
3215 this.menu.element.hide();
3216 this.menu.blur();
3217 this.isNewMenu = true;
3218 this._trigger( "close", event );
3219 }
3220 },
3221
3222 _change: function( event ) {
3223 if ( this.previous !== this._value() ) {
3224 this._trigger( "change", event, { item: this.selectedItem } );
3225 }
3226 },
3227
3228 _normalize: function( items ) {
3229 // assume all items have the right format when the first item is complete
3230 if ( items.length && items[ 0 ].label && items[ 0 ].value ) {
3231 return items;
3232 }
3233 return $.map( items, function( item ) {
3234 if ( typeof item === "string" ) {
3235 return {
3236 label: item,
3237 value: item
3238 };
3239 }
3240 return $.extend( {}, item, {
3241 label: item.label || item.value,
3242 value: item.value || item.label
3243 });
3244 });
3245 },
3246
3247 _suggest: function( items ) {
3248 var ul = this.menu.element.empty();
3249 this._renderMenu( ul, items );
3250 this.isNewMenu = true;
3251 this.menu.refresh();
3252
3253 // size and position menu
3254 ul.show();
3255 this._resizeMenu();
3256 ul.position( $.extend({
3257 of: this.element
3258 }, this.options.position ) );
3259
3260 if ( this.options.autoFocus ) {
3261 this.menu.next();
3262 }
3263 },
3264
3265 _resizeMenu: function() {
3266 var ul = this.menu.element;
3267 ul.outerWidth( Math.max(
3268 // Firefox wraps long text (possibly a rounding bug)
3269 // so we add 1px to avoid the wrapping (#7513)
3270 ul.width( "" ).outerWidth() + 1,
3271 this.element.outerWidth()
3272 ) );
3273 },
3274
3275 _renderMenu: function( ul, items ) {
3276 var that = this;
3277 $.each( items, function( index, item ) {
3278 that._renderItemData( ul, item );
3279 });
3280 },
3281
3282 _renderItemData: function( ul, item ) {
3283 return this._renderItem( ul, item ).data( "ui-autocomplete-item", item );
3284 },
3285
3286 _renderItem: function( ul, item ) {
3287 return $( "<li>" ).text( item.label ).appendTo( ul );
3288 },
3289
3290 _move: function( direction, event ) {
3291 if ( !this.menu.element.is( ":visible" ) ) {
3292 this.search( null, event );
3293 return;
3294 }
3295 if ( this.menu.isFirstItem() && /^previous/.test( direction ) ||
3296 this.menu.isLastItem() && /^next/.test( direction ) ) {
3297
3298 if ( !this.isMultiLine ) {
3299 this._value( this.term );
3300 }
3301
3302 this.menu.blur();
3303 return;
3304 }
3305 this.menu[ direction ]( event );
3306 },
3307
3308 widget: function() {
3309 return this.menu.element;
3310 },
3311
3312 _value: function() {
3313 return this.valueMethod.apply( this.element, arguments );
3314 },
3315
3316 _keyEvent: function( keyEvent, event ) {
3317 if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
3318 this._move( keyEvent, event );
3319
3320 // prevents moving cursor to beginning/end of the text field in some browsers
3321 event.preventDefault();
3322 }
3323 }
3324 });
3325
3326 $.extend( $.ui.autocomplete, {
3327 escapeRegex: function( value ) {
3328 return value.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" );
3329 },
3330 filter: function( array, term ) {
3331 var matcher = new RegExp( $.ui.autocomplete.escapeRegex( term ), "i" );
3332 return $.grep( array, function( value ) {
3333 return matcher.test( value.label || value.value || value );
3334 });
3335 }
3336 });
3337
3338 // live region extension, adding a `messages` option
3339 // NOTE: This is an experimental API. We are still investigating
3340 // a full solution for string manipulation and internationalization.
3341 $.widget( "ui.autocomplete", $.ui.autocomplete, {
3342 options: {
3343 messages: {
3344 noResults: "No search results.",
3345 results: function( amount ) {
3346 return amount + ( amount > 1 ? " results are" : " result is" ) +
3347 " available, use up and down arrow keys to navigate.";
3348 }
3349 }
3350 },
3351
3352 __response: function( content ) {
3353 var message;
3354 this._superApply( arguments );
3355 if ( this.options.disabled || this.cancelSearch ) {
3356 return;
3357 }
3358 if ( content && content.length ) {
3359 message = this.options.messages.results( content.length );
3360 } else {
3361 message = this.options.messages.noResults;
3362 }
3363 this.liveRegion.children().hide();
3364 $( "<div>" ).text( message ).appendTo( this.liveRegion );
3365 }
3366 });
3367
3368 var autocomplete = $.ui.autocomplete;
3369
3370
3371 /*!
3372 * jQuery UI Button 1.11.4
3373 * http://jqueryui.com
3374 *
3375 * Copyright jQuery Foundation and other contributors
3376 * Released under the MIT license.
3377 * http://jquery.org/license
3378 *
3379 * http://api.jqueryui.com/button/
3380 */
3381
3382
3383 var lastActive,
3384 baseClasses = "ui-button ui-widget ui-state-default ui-corner-all",
3385 typeClasses = "ui-button-icons-only ui-button-icon-only ui-button-text-icons ui-button-text-icon-primary ui-button-text-icon-secondary ui-button-text-only",
3386 formResetHandler = function() {
3387 var form = $( this );
3388 setTimeout(function() {
3389 form.find( ":ui-button" ).button( "refresh" );
3390 }, 1 );
3391 },
3392 radioGroup = function( radio ) {
3393 var name = radio.name,
3394 form = radio.form,
3395 radios = $( [] );
3396 if ( name ) {
3397 name = name.replace( /'/g, "\\'" );
3398 if ( form ) {
3399 radios = $( form ).find( "[name='" + name + "'][type=radio]" );
3400 } else {
3401 radios = $( "[name='" + name + "'][type=radio]", radio.ownerDocument )
3402 .filter(function() {
3403 return !this.form;
3404 });
3405 }
3406 }
3407 return radios;
3408 };
3409
3410 $.widget( "ui.button", {
3411 version: "1.11.4",
3412 defaultElement: "<button>",
3413 options: {
3414 disabled: null,
3415 text: true,
3416 label: null,
3417 icons: {
3418 primary: null,
3419 secondary: null
3420 }
3421 },
3422 _create: function() {
3423 this.element.closest( "form" )
3424 .unbind( "reset" + this.eventNamespace )
3425 .bind( "reset" + this.eventNamespace, formResetHandler );
3426
3427 if ( typeof this.options.disabled !== "boolean" ) {
3428 this.options.disabled = !!this.element.prop( "disabled" );
3429 } else {
3430 this.element.prop( "disabled", this.options.disabled );
3431 }
3432
3433 this._determineButtonType();
3434 this.hasTitle = !!this.buttonElement.attr( "title" );
3435
3436 var that = this,
3437 options = this.options,
3438 toggleButton = this.type === "checkbox" || this.type === "radio",
3439 activeClass = !toggleButton ? "ui-state-active" : "";
3440
3441 if ( options.label === null ) {
3442 options.label = (this.type === "input" ? this.buttonElement.val() : this.buttonElement.html());
3443 }
3444
3445 this._hoverable( this.buttonElement );
3446
3447 this.buttonElement
3448 .addClass( baseClasses )
3449 .attr( "role", "button" )
3450 .bind( "mouseenter" + this.eventNamespace, function() {
3451 if ( options.disabled ) {
3452 return;
3453 }
3454 if ( this === lastActive ) {
3455 $( this ).addClass( "ui-state-active" );
3456 }
3457 })
3458 .bind( "mouseleave" + this.eventNamespace, function() {
3459 if ( options.disabled ) {
3460 return;
3461 }
3462 $( this ).removeClass( activeClass );
3463 })
3464 .bind( "click" + this.eventNamespace, function( event ) {
3465 if ( options.disabled ) {
3466 event.preventDefault();
3467 event.stopImmediatePropagation();
3468 }
3469 });
3470
3471 // Can't use _focusable() because the element that receives focus
3472 // and the element that gets the ui-state-focus class are different
3473 this._on({
3474 focus: function() {
3475 this.buttonElement.addClass( "ui-state-focus" );
3476 },
3477 blur: function() {
3478 this.buttonElement.removeClass( "ui-state-focus" );
3479 }
3480 });
3481
3482 if ( toggleButton ) {
3483 this.element.bind( "change" + this.eventNamespace, function() {
3484 that.refresh();
3485 });
3486 }
3487
3488 if ( this.type === "checkbox" ) {
3489 this.buttonElement.bind( "click" + this.eventNamespace, function() {
3490 if ( options.disabled ) {
3491 return false;
3492 }
3493 });
3494 } else if ( this.type === "radio" ) {
3495 this.buttonElement.bind( "click" + this.eventNamespace, function() {
3496 if ( options.disabled ) {
3497 return false;
3498 }
3499 $( this ).addClass( "ui-state-active" );
3500 that.buttonElement.attr( "aria-pressed", "true" );
3501
3502 var radio = that.element[ 0 ];
3503 radioGroup( radio )
3504 .not( radio )
3505 .map(function() {
3506 return $( this ).button( "widget" )[ 0 ];
3507 })
3508 .removeClass( "ui-state-active" )
3509 .attr( "aria-pressed", "false" );
3510 });
3511 } else {
3512 this.buttonElement
3513 .bind( "mousedown" + this.eventNamespace, function() {
3514 if ( options.disabled ) {
3515 return false;
3516 }
3517 $( this ).addClass( "ui-state-active" );
3518 lastActive = this;
3519 that.document.one( "mouseup", function() {
3520 lastActive = null;
3521 });
3522 })
3523 .bind( "mouseup" + this.eventNamespace, function() {
3524 if ( options.disabled ) {
3525 return false;
3526 }
3527 $( this ).removeClass( "ui-state-active" );
3528 })
3529 .bind( "keydown" + this.eventNamespace, function(event) {
3530 if ( options.disabled ) {
3531 return false;
3532 }
3533 if ( event.keyCode === $.ui.keyCode.SPACE || event.keyCode === $.ui.keyCode.ENTER ) {
3534 $( this ).addClass( "ui-state-active" );
3535 }
3536 })
3537 // see #8559, we bind to blur here in case the button element loses
3538 // focus between keydown and keyup, it would be left in an "active" state
3539 .bind( "keyup" + this.eventNamespace + " blur" + this.eventNamespace, function() {
3540 $( this ).removeClass( "ui-state-active" );
3541 });
3542
3543 if ( this.buttonElement.is("a") ) {
3544 this.buttonElement.keyup(function(event) {
3545 if ( event.keyCode === $.ui.keyCode.SPACE ) {
3546 // TODO pass through original event correctly (just as 2nd argument doesn't work)
3547 $( this ).click();
3548 }
3549 });
3550 }
3551 }
3552
3553 this._setOption( "disabled", options.disabled );
3554 this._resetButton();
3555 },
3556
3557 _determineButtonType: function() {
3558 var ancestor, labelSelector, checked;
3559
3560 if ( this.element.is("[type=checkbox]") ) {
3561 this.type = "checkbox";
3562 } else if ( this.element.is("[type=radio]") ) {
3563 this.type = "radio";
3564 } else if ( this.element.is("input") ) {
3565 this.type = "input";
3566 } else {
3567 this.type = "button";
3568 }
3569
3570 if ( this.type === "checkbox" || this.type === "radio" ) {
3571 // we don't search against the document in case the element
3572 // is disconnected from the DOM
3573 ancestor = this.element.parents().last();
3574 labelSelector = "label[for='" + this.element.attr("id") + "']";
3575 this.buttonElement = ancestor.find( labelSelector );
3576 if ( !this.buttonElement.length ) {
3577 ancestor = ancestor.length ? ancestor.siblings() : this.element.siblings();
3578 this.buttonElement = ancestor.filter( labelSelector );
3579 if ( !this.buttonElement.length ) {
3580 this.buttonElement = ancestor.find( labelSelector );
3581 }
3582 }
3583 this.element.addClass( "ui-helper-hidden-accessible" );
3584
3585 checked = this.element.is( ":checked" );
3586 if ( checked ) {
3587 this.buttonElement.addClass( "ui-state-active" );
3588 }
3589 this.buttonElement.prop( "aria-pressed", checked );
3590 } else {
3591 this.buttonElement = this.element;
3592 }
3593 },
3594
3595 widget: function() {
3596 return this.buttonElement;
3597 },
3598
3599 _destroy: function() {
3600 this.element
3601 .removeClass( "ui-helper-hidden-accessible" );
3602 this.buttonElement
3603 .removeClass( baseClasses + " ui-state-active " + typeClasses )
3604 .removeAttr( "role" )
3605 .removeAttr( "aria-pressed" )
3606 .html( this.buttonElement.find(".ui-button-text").html() );
3607
3608 if ( !this.hasTitle ) {
3609 this.buttonElement.removeAttr( "title" );
3610 }
3611 },
3612
3613 _setOption: function( key, value ) {
3614 this._super( key, value );
3615 if ( key === "disabled" ) {
3616 this.widget().toggleClass( "ui-state-disabled", !!value );
3617 this.element.prop( "disabled", !!value );
3618 if ( value ) {
3619 if ( this.type === "checkbox" || this.type === "radio" ) {
3620 this.buttonElement.removeClass( "ui-state-focus" );
3621 } else {
3622 this.buttonElement.removeClass( "ui-state-focus ui-state-active" );
3623 }
3624 }
3625 return;
3626 }
3627 this._resetButton();
3628 },
3629
3630 refresh: function() {
3631 //See #8237 & #8828
3632 var isDisabled = this.element.is( "input, button" ) ? this.element.is( ":disabled" ) : this.element.hasClass( "ui-button-disabled" );
3633
3634 if ( isDisabled !== this.options.disabled ) {
3635 this._setOption( "disabled", isDisabled );
3636 }
3637 if ( this.type === "radio" ) {
3638 radioGroup( this.element[0] ).each(function() {
3639 if ( $( this ).is( ":checked" ) ) {
3640 $( this ).button( "widget" )
3641 .addClass( "ui-state-active" )
3642 .attr( "aria-pressed", "true" );
3643 } else {
3644 $( this ).button( "widget" )
3645 .removeClass( "ui-state-active" )
3646 .attr( "aria-pressed", "false" );
3647 }
3648 });
3649 } else if ( this.type === "checkbox" ) {
3650 if ( this.element.is( ":checked" ) ) {
3651 this.buttonElement
3652 .addClass( "ui-state-active" )
3653 .attr( "aria-pressed", "true" );
3654 } else {
3655 this.buttonElement
3656 .removeClass( "ui-state-active" )
3657 .attr( "aria-pressed", "false" );
3658 }
3659 }
3660 },
3661
3662 _resetButton: function() {
3663 if ( this.type === "input" ) {
3664 if ( this.options.label ) {
3665 this.element.val( this.options.label );
3666 }
3667 return;
3668 }
3669 var buttonElement = this.buttonElement.removeClass( typeClasses ),
3670 buttonText = $( "<span></span>", this.document[0] )
3671 .addClass( "ui-button-text" )
3672 .html( this.options.label )
3673 .appendTo( buttonElement.empty() )
3674 .text(),
3675 icons = this.options.icons,
3676 multipleIcons = icons.primary && icons.secondary,
3677 buttonClasses = [];
3678
3679 if ( icons.primary || icons.secondary ) {
3680 if ( this.options.text ) {
3681 buttonClasses.push( "ui-button-text-icon" + ( multipleIcons ? "s" : ( icons.primary ? "-primary" : "-secondary" ) ) );
3682 }
3683
3684 if ( icons.primary ) {
3685 buttonElement.prepend( "<span class='ui-button-icon-primary ui-icon " + icons.primary + "'></span>" );
3686 }
3687
3688 if ( icons.secondary ) {
3689 buttonElement.append( "<span class='ui-button-icon-secondary ui-icon " + icons.secondary + "'></span>" );
3690 }
3691
3692 if ( !this.options.text ) {
3693 buttonClasses.push( multipleIcons ? "ui-button-icons-only" : "ui-button-icon-only" );
3694
3695 if ( !this.hasTitle ) {
3696 buttonElement.attr( "title", $.trim( buttonText ) );
3697 }
3698 }
3699 } else {
3700 buttonClasses.push( "ui-button-text-only" );
3701 }
3702 buttonElement.addClass( buttonClasses.join( " " ) );
3703 }
3704 });
3705
3706 $.widget( "ui.buttonset", {
3707 version: "1.11.4",
3708 options: {
3709 items: "button, input[type=button], input[type=submit], input[type=reset], input[type=checkbox], input[type=radio], a, :data(ui-button)"
3710 },
3711
3712 _create: function() {
3713 this.element.addClass( "ui-buttonset" );
3714 },
3715
3716 _init: function() {
3717 this.refresh();
3718 },
3719
3720 _setOption: function( key, value ) {
3721 if ( key === "disabled" ) {
3722 this.buttons.button( "option", key, value );
3723 }
3724
3725 this._super( key, value );
3726 },
3727
3728 refresh: function() {
3729 var rtl = this.element.css( "direction" ) === "rtl",
3730 allButtons = this.element.find( this.options.items ),
3731 existingButtons = allButtons.filter( ":ui-button" );
3732
3733 // Initialize new buttons
3734 allButtons.not( ":ui-button" ).button();
3735
3736 // Refresh existing buttons
3737 existingButtons.button( "refresh" );
3738
3739 this.buttons = allButtons
3740 .map(function() {
3741 return $( this ).button( "widget" )[ 0 ];
3742 })
3743 .removeClass( "ui-corner-all ui-corner-left ui-corner-right" )
3744 .filter( ":first" )
3745 .addClass( rtl ? "ui-corner-right" : "ui-corner-left" )
3746 .end()
3747 .filter( ":last" )
3748 .addClass( rtl ? "ui-corner-left" : "ui-corner-right" )
3749 .end()
3750 .end();
3751 },
3752
3753 _destroy: function() {
3754 this.element.removeClass( "ui-buttonset" );
3755 this.buttons
3756 .map(function() {
3757 return $( this ).button( "widget" )[ 0 ];
3758 })
3759 .removeClass( "ui-corner-left ui-corner-right" )
3760 .end()
3761 .button( "destroy" );
3762 }
3763 });
3764
3765 var button = $.ui.button;
3766
3767
3768 /*!
3769 * jQuery UI Datepicker 1.11.4
3770 * http://jqueryui.com
3771 *
3772 * Copyright jQuery Foundation and other contributors
3773 * Released under the MIT license.
3774 * http://jquery.org/license
3775 *
3776 * http://api.jqueryui.com/datepicker/
3777 */
3778
3779
3780 $.extend($.ui, { datepicker: { version: "1.11.4" } });
3781
3782 var datepicker_instActive;
3783
3784 function datepicker_getZindex( elem ) {
3785 var position, value;
3786 while ( elem.length && elem[ 0 ] !== document ) {
3787 // Ignore z-index if position is set to a value where z-index is ignored by the browser
3788 // This makes behavior of this function consistent across browsers
3789 // WebKit always returns auto if the element is positioned
3790 position = elem.css( "position" );
3791 if ( position === "absolute" || position === "relative" || position === "fixed" ) {
3792 // IE returns 0 when zIndex is not specified
3793 // other browsers return a string
3794 // we ignore the case of nested elements with an explicit value of 0
3795 // <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
3796 value = parseInt( elem.css( "zIndex" ), 10 );
3797 if ( !isNaN( value ) && value !== 0 ) {
3798 return value;
3799 }
3800 }
3801 elem = elem.parent();
3802 }
3803
3804 return 0;
3805 }
3806 /* Date picker manager.
3807 Use the singleton instance of this class, $.datepicker, to interact with the date picker.
3808 Settings for (groups of) date pickers are maintained in an instance object,
3809 allowing multiple different settings on the same page. */
3810
3811 function Datepicker() {
3812 this._curInst = null; // The current instance in use
3813 this._keyEvent = false; // If the last event was a key event
3814 this._disabledInputs = []; // List of date picker inputs that have been disabled
3815 this._datepickerShowing = false; // True if the popup picker is showing , false if not
3816 this._inDialog = false; // True if showing within a "dialog", false if not
3817 this._mainDivId = "ui-datepicker-div"; // The ID of the main datepicker division
3818 this._inlineClass = "ui-datepicker-inline"; // The name of the inline marker class
3819 this._appendClass = "ui-datepicker-append"; // The name of the append marker class
3820 this._triggerClass = "ui-datepicker-trigger"; // The name of the trigger marker class
3821 this._dialogClass = "ui-datepicker-dialog"; // The name of the dialog marker class
3822 this._disableClass = "ui-datepicker-disabled"; // The name of the disabled covering marker class
3823 this._unselectableClass = "ui-datepicker-unselectable"; // The name of the unselectable cell marker class
3824 this._currentClass = "ui-datepicker-current-day"; // The name of the current day marker class
3825 this._dayOverClass = "ui-datepicker-days-cell-over"; // The name of the day hover marker class
3826 this.regional = []; // Available regional settings, indexed by language code
3827 this.regional[""] = { // Default regional settings
3828 closeText: "Done", // Display text for close link
3829 prevText: "Prev", // Display text for previous month link
3830 nextText: "Next", // Display text for next month link
3831 currentText: "Today", // Display text for current month link
3832 monthNames: ["January","February","March","April","May","June",
3833 "July","August","September","October","November","December"], // Names of months for drop-down and formatting
3834 monthNamesShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], // For formatting
3835 dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], // For formatting
3836 dayNamesShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], // For formatting
3837 dayNamesMin: ["Su","Mo","Tu","We","Th","Fr","Sa"], // Column headings for days starting at Sunday
3838 weekHeader: "Wk", // Column header for week of the year
3839 dateFormat: "mm/dd/yy", // See format options on parseDate
3840 firstDay: 0, // The first day of the week, Sun = 0, Mon = 1, ...
3841 isRTL: false, // True if right-to-left language, false if left-to-right
3842 showMonthAfterYear: false, // True if the year select precedes month, false for month then year
3843 yearSuffix: "" // Additional text to append to the year in the month headers
3844 };
3845 this._defaults = { // Global defaults for all the date picker instances
3846 showOn: "focus", // "focus" for popup on focus,
3847 // "button" for trigger button, or "both" for either
3848 showAnim: "fadeIn", // Name of jQuery animation for popup
3849 showOptions: {}, // Options for enhanced animations
3850 defaultDate: null, // Used when field is blank: actual date,
3851 // +/-number for offset from today, null for today
3852 appendText: "", // Display text following the input box, e.g. showing the format
3853 buttonText: "...", // Text for trigger button
3854 buttonImage: "", // URL for trigger button image
3855 buttonImageOnly: false, // True if the image appears alone, false if it appears on a button
3856 hideIfNoPrevNext: false, // True to hide next/previous month links
3857 // if not applicable, false to just disable them
3858 navigationAsDateFormat: false, // True if date formatting applied to prev/today/next links
3859 gotoCurrent: false, // True if today link goes back to current selection instead
3860 changeMonth: false, // True if month can be selected directly, false if only prev/next
3861 changeYear: false, // True if year can be selected directly, false if only prev/next
3862 yearRange: "c-10:c+10", // Range of years to display in drop-down,
3863 // either relative to today's year (-nn:+nn), relative to currently displayed year
3864 // (c-nn:c+nn), absolute (nnnn:nnnn), or a combination of the above (nnnn:-n)
3865 showOtherMonths: false, // True to show dates in other months, false to leave blank
3866 selectOtherMonths: false, // True to allow selection of dates in other months, false for unselectable
3867 showWeek: false, // True to show week of the year, false to not show it
3868 calculateWeek: this.iso8601Week, // How to calculate the week of the year,
3869 // takes a Date and returns the number of the week for it
3870 shortYearCutoff: "+10", // Short year values < this are in the current century,
3871 // > this are in the previous century,
3872 // string value starting with "+" for current year + value
3873 minDate: null, // The earliest selectable date, or null for no limit
3874 maxDate: null, // The latest selectable date, or null for no limit
3875 duration: "fast", // Duration of display/closure
3876 beforeShowDay: null, // Function that takes a date and returns an array with
3877 // [0] = true if selectable, false if not, [1] = custom CSS class name(s) or "",
3878 // [2] = cell title (optional), e.g. $.datepicker.noWeekends
3879 beforeShow: null, // Function that takes an input field and
3880 // returns a set of custom settings for the date picker
3881 onSelect: null, // Define a callback function when a date is selected
3882 onChangeMonthYear: null, // Define a callback function when the month or year is changed
3883 onClose: null, // Define a callback function when the datepicker is closed
3884 numberOfMonths: 1, // Number of months to show at a time
3885 showCurrentAtPos: 0, // The position in multipe months at which to show the current month (starting at 0)
3886 stepMonths: 1, // Number of months to step back/forward
3887 stepBigMonths: 12, // Number of months to step back/forward for the big links
3888 altField: "", // Selector for an alternate field to store selected dates into
3889 altFormat: "", // The date format to use for the alternate field
3890 constrainInput: true, // The input is constrained by the current date format
3891 showButtonPanel: false, // True to show button panel, false to not show it
3892 autoSize: false, // True to size the input for the date format, false to leave as is
3893 disabled: false // The initial disabled state
3894 };
3895 $.extend(this._defaults, this.regional[""]);
3896 this.regional.en = $.extend( true, {}, this.regional[ "" ]);
3897 this.regional[ "en-US" ] = $.extend( true, {}, this.regional.en );
3898 this.dpDiv = datepicker_bindHover($("<div id='" + this._mainDivId + "' class='ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>"));
3899 }
3900
3901 $.extend(Datepicker.prototype, {
3902 /* Class name added to elements to indicate already configured with a date picker. */
3903 markerClassName: "hasDatepicker",
3904
3905 //Keep track of the maximum number of rows displayed (see #7043)
3906 maxRows: 4,
3907
3908 // TODO rename to "widget" when switching to widget factory
3909 _widgetDatepicker: function() {
3910 return this.dpDiv;
3911 },
3912
3913 /* Override the default settings for all instances of the date picker.
3914 * @param settings object - the new settings to use as defaults (anonymous object)
3915 * @return the manager object
3916 */
3917 setDefaults: function(settings) {
3918 datepicker_extendRemove(this._defaults, settings || {});
3919 return this;
3920 },
3921
3922 /* Attach the date picker to a jQuery selection.
3923 * @param target element - the target input field or division or span
3924 * @param settings object - the new settings to use for this date picker instance (anonymous)
3925 */
3926 _attachDatepicker: function(target, settings) {
3927 var nodeName, inline, inst;
3928 nodeName = target.nodeName.toLowerCase();
3929 inline = (nodeName === "div" || nodeName === "span");
3930 if (!target.id) {
3931 this.uuid += 1;
3932 target.id = "dp" + this.uuid;
3933 }
3934 inst = this._newInst($(target), inline);
3935 inst.settings = $.extend({}, settings || {});
3936 if (nodeName === "input") {
3937 this._connectDatepicker(target, inst);
3938 } else if (inline) {
3939 this._inlineDatepicker(target, inst);
3940 }
3941 },
3942
3943 /* Create a new instance object. */
3944 _newInst: function(target, inline) {
3945 var id = target[0].id.replace(/([^A-Za-z0-9_\-])/g, "\\\\$1"); // escape jQuery meta chars
3946 return {id: id, input: target, // associated target
3947 selectedDay: 0, selectedMonth: 0, selectedYear: 0, // current selection
3948 drawMonth: 0, drawYear: 0, // month being drawn
3949 inline: inline, // is datepicker inline or not
3950 dpDiv: (!inline ? this.dpDiv : // presentation div
3951 datepicker_bindHover($("<div class='" + this._inlineClass + " ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>")))};
3952 },
3953
3954 /* Attach the date picker to an input field. */
3955 _connectDatepicker: function(target, inst) {
3956 var input = $(target);
3957 inst.append = $([]);
3958 inst.trigger = $([]);
3959 if (input.hasClass(this.markerClassName)) {
3960 return;
3961 }
3962 this._attachments(input, inst);
3963 input.addClass(this.markerClassName).keydown(this._doKeyDown).
3964 keypress(this._doKeyPress).keyup(this._doKeyUp);
3965 this._autoSize(inst);
3966 $.data(target, "datepicker", inst);
3967 //If disabled option is true, disable the datepicker once it has been attached to the input (see ticket #5665)
3968 if( inst.settings.disabled ) {
3969 this._disableDatepicker( target );
3970 }
3971 },
3972
3973 /* Make attachments based on settings. */
3974 _attachments: function(input, inst) {
3975 var showOn, buttonText, buttonImage,
3976 appendText = this._get(inst, "appendText"),
3977 isRTL = this._get(inst, "isRTL");
3978
3979 if (inst.append) {
3980 inst.append.remove();
3981 }
3982 if (appendText) {
3983 inst.append = $("<span class='" + this._appendClass + "'>" + appendText + "</span>");
3984 input[isRTL ? "before" : "after"](inst.append);
3985 }
3986
3987 input.unbind("focus", this._showDatepicker);
3988
3989 if (inst.trigger) {
3990 inst.trigger.remove();
3991 }
3992
3993 showOn = this._get(inst, "showOn");
3994 if (showOn === "focus" || showOn === "both") { // pop-up date picker when in the marked field
3995 input.focus(this._showDatepicker);
3996 }
3997 if (showOn === "button" || showOn === "both") { // pop-up date picker when button clicked
3998 buttonText = this._get(inst, "buttonText");
3999 buttonImage = this._get(inst, "buttonImage");
4000 inst.trigger = $(this._get(inst, "buttonImageOnly") ?
4001 $("<img/>").addClass(this._triggerClass).
4002 attr({ src: buttonImage, alt: buttonText, title: buttonText }) :
4003 $("<button type='button'></button>").addClass(this._triggerClass).
4004 html(!buttonImage ? buttonText : $("<img/>").attr(
4005 { src:buttonImage, alt:buttonText, title:buttonText })));
4006 input[isRTL ? "before" : "after"](inst.trigger);
4007 inst.trigger.click(function() {
4008 if ($.datepicker._datepickerShowing && $.datepicker._lastInput === input[0]) {
4009 $.datepicker._hideDatepicker();
4010 } else if ($.datepicker._datepickerShowing && $.datepicker._lastInput !== input[0]) {
4011 $.datepicker._hideDatepicker();
4012 $.datepicker._showDatepicker(input[0]);
4013 } else {
4014 $.datepicker._showDatepicker(input[0]);
4015 }
4016 return false;
4017 });
4018 }
4019 },
4020
4021 /* Apply the maximum length for the date format. */
4022 _autoSize: function(inst) {
4023 if (this._get(inst, "autoSize") && !inst.inline) {
4024 var findMax, max, maxI, i,
4025 date = new Date(2009, 12 - 1, 20), // Ensure double digits
4026 dateFormat = this._get(inst, "dateFormat");
4027
4028 if (dateFormat.match(/[DM]/)) {
4029 findMax = function(names) {
4030 max = 0;
4031 maxI = 0;
4032 for (i = 0; i < names.length; i++) {
4033 if (names[i].length > max) {
4034 max = names[i].length;
4035 maxI = i;
4036 }
4037 }
4038 return maxI;
4039 };
4040 date.setMonth(findMax(this._get(inst, (dateFormat.match(/MM/) ?
4041 "monthNames" : "monthNamesShort"))));
4042 date.setDate(findMax(this._get(inst, (dateFormat.match(/DD/) ?
4043 "dayNames" : "dayNamesShort"))) + 20 - date.getDay());
4044 }
4045 inst.input.attr("size", this._formatDate(inst, date).length);
4046 }
4047 },
4048
4049 /* Attach an inline date picker to a div. */
4050 _inlineDatepicker: function(target, inst) {
4051 var divSpan = $(target);
4052 if (divSpan.hasClass(this.markerClassName)) {
4053 return;
4054 }
4055 divSpan.addClass(this.markerClassName).append(inst.dpDiv);
4056 $.data(target, "datepicker", inst);
4057 this._setDate(inst, this._getDefaultDate(inst), true);
4058 this._updateDatepicker(inst);
4059 this._updateAlternate(inst);
4060 //If disabled option is true, disable the datepicker before showing it (see ticket #5665)
4061 if( inst.settings.disabled ) {
4062 this._disableDatepicker( target );
4063 }
4064 // Set display:block in place of inst.dpDiv.show() which won't work on disconnected elements
4065 // http://bugs.jqueryui.com/ticket/7552 - A Datepicker created on a detached div has zero height
4066 inst.dpDiv.css( "display", "block" );
4067 },
4068
4069 /* Pop-up the date picker in a "dialog" box.
4070 * @param input element - ignored
4071 * @param date string or Date - the initial date to display
4072 * @param onSelect function - the function to call when a date is selected
4073 * @param settings object - update the dialog date picker instance's settings (anonymous object)
4074 * @param pos int[2] - coordinates for the dialog's position within the screen or
4075 * event - with x/y coordinates or
4076 * leave empty for default (screen centre)
4077 * @return the manager object
4078 */
4079 _dialogDatepicker: function(input, date, onSelect, settings, pos) {
4080 var id, browserWidth, browserHeight, scrollX, scrollY,
4081 inst = this._dialogInst; // internal instance
4082
4083 if (!inst) {
4084 this.uuid += 1;
4085 id = "dp" + this.uuid;
4086 this._dialogInput = $("<input type='text' id='" + id +
4087 "' style='position: absolute; top: -100px; width: 0px;'/>");
4088 this._dialogInput.keydown(this._doKeyDown);
4089 $("body").append(this._dialogInput);
4090 inst = this._dialogInst = this._newInst(this._dialogInput, false);
4091 inst.settings = {};
4092 $.data(this._dialogInput[0], "datepicker", inst);
4093 }
4094 datepicker_extendRemove(inst.settings, settings || {});
4095 date = (date && date.constructor === Date ? this._formatDate(inst, date) : date);
4096 this._dialogInput.val(date);
4097
4098 this._pos = (pos ? (pos.length ? pos : [pos.pageX, pos.pageY]) : null);
4099 if (!this._pos) {
4100 browserWidth = document.documentElement.clientWidth;
4101 browserHeight = document.documentElement.clientHeight;
4102 scrollX = document.documentElement.scrollLeft || document.body.scrollLeft;
4103 scrollY = document.documentElement.scrollTop || document.body.scrollTop;
4104 this._pos = // should use actual width/height below
4105 [(browserWidth / 2) - 100 + scrollX, (browserHeight / 2) - 150 + scrollY];
4106 }
4107
4108 // move input on screen for focus, but hidden behind dialog
4109 this._dialogInput.css("left", (this._pos[0] + 20) + "px").css("top", this._pos[1] + "px");
4110 inst.settings.onSelect = onSelect;
4111 this._inDialog = true;
4112 this.dpDiv.addClass(this._dialogClass);
4113 this._showDatepicker(this._dialogInput[0]);
4114 if ($.blockUI) {
4115 $.blockUI(this.dpDiv);
4116 }
4117 $.data(this._dialogInput[0], "datepicker", inst);
4118 return this;
4119 },
4120
4121 /* Detach a datepicker from its control.
4122 * @param target element - the target input field or division or span
4123 */
4124 _destroyDatepicker: function(target) {
4125 var nodeName,
4126 $target = $(target),
4127 inst = $.data(target, "datepicker");
4128
4129 if (!$target.hasClass(this.markerClassName)) {
4130 return;
4131 }
4132
4133 nodeName = target.nodeName.toLowerCase();
4134 $.removeData(target, "datepicker");
4135 if (nodeName === "input") {
4136 inst.append.remove();
4137 inst.trigger.remove();
4138 $target.removeClass(this.markerClassName).
4139 unbind("focus", this._showDatepicker).
4140 unbind("keydown", this._doKeyDown).
4141 unbind("keypress", this._doKeyPress).
4142 unbind("keyup", this._doKeyUp);
4143 } else if (nodeName === "div" || nodeName === "span") {
4144 $target.removeClass(this.markerClassName).empty();
4145 }
4146
4147 if ( datepicker_instActive === inst ) {
4148 datepicker_instActive = null;
4149 }
4150 },
4151
4152 /* Enable the date picker to a jQuery selection.
4153 * @param target element - the target input field or division or span
4154 */
4155 _enableDatepicker: function(target) {
4156 var nodeName, inline,
4157 $target = $(target),
4158 inst = $.data(target, "datepicker");
4159
4160 if (!$target.hasClass(this.markerClassName)) {
4161 return;
4162 }
4163
4164 nodeName = target.nodeName.toLowerCase();
4165 if (nodeName === "input") {
4166 target.disabled = false;
4167 inst.trigger.filter("button").
4168 each(function() { this.disabled = false; }).end().
4169 filter("img").css({opacity: "1.0", cursor: ""});
4170 } else if (nodeName === "div" || nodeName === "span") {
4171 inline = $target.children("." + this._inlineClass);
4172 inline.children().removeClass("ui-state-disabled");
4173 inline.find("select.ui-datepicker-month, select.ui-datepicker-year").
4174 prop("disabled", false);
4175 }
4176 this._disabledInputs = $.map(this._disabledInputs,
4177 function(value) { return (value === target ? null : value); }); // delete entry
4178 },
4179
4180 /* Disable the date picker to a jQuery selection.
4181 * @param target element - the target input field or division or span
4182 */
4183 _disableDatepicker: function(target) {
4184 var nodeName, inline,
4185 $target = $(target),
4186 inst = $.data(target, "datepicker");
4187
4188 if (!$target.hasClass(this.markerClassName)) {
4189 return;
4190 }
4191
4192 nodeName = target.nodeName.toLowerCase();
4193 if (nodeName === "input") {
4194 target.disabled = true;
4195 inst.trigger.filter("button").
4196 each(function() { this.disabled = true; }).end().
4197 filter("img").css({opacity: "0.5", cursor: "default"});
4198 } else if (nodeName === "div" || nodeName === "span") {
4199 inline = $target.children("." + this._inlineClass);
4200 inline.children().addClass("ui-state-disabled");
4201 inline.find("select.ui-datepicker-month, select.ui-datepicker-year").
4202 prop("disabled", true);
4203 }
4204 this._disabledInputs = $.map(this._disabledInputs,
4205 function(value) { return (value === target ? null : value); }); // delete entry
4206 this._disabledInputs[this._disabledInputs.length] = target;
4207 },
4208
4209 /* Is the first field in a jQuery collection disabled as a datepicker?
4210 * @param target element - the target input field or division or span
4211 * @return boolean - true if disabled, false if enabled
4212 */
4213 _isDisabledDatepicker: function(target) {
4214 if (!target) {
4215 return false;
4216 }
4217 for (var i = 0; i < this._disabledInputs.length; i++) {
4218 if (this._disabledInputs[i] === target) {
4219 return true;
4220 }
4221 }
4222 return false;
4223 },
4224
4225 /* Retrieve the instance data for the target control.
4226 * @param target element - the target input field or division or span
4227 * @return object - the associated instance data
4228 * @throws error if a jQuery problem getting data
4229 */
4230 _getInst: function(target) {
4231 try {
4232 return $.data(target, "datepicker");
4233 }
4234 catch (err) {
4235 throw "Missing instance data for this datepicker";
4236 }
4237 },
4238
4239 /* Update or retrieve the settings for a date picker attached to an input field or division.
4240 * @param target element - the target input field or division or span
4241 * @param name object - the new settings to update or
4242 * string - the name of the setting to change or retrieve,
4243 * when retrieving also "all" for all instance settings or
4244 * "defaults" for all global defaults
4245 * @param value any - the new value for the setting
4246 * (omit if above is an object or to retrieve a value)
4247 */
4248 _optionDatepicker: function(target, name, value) {
4249 var settings, date, minDate, maxDate,
4250 inst = this._getInst(target);
4251
4252 if (arguments.length === 2 && typeof name === "string") {
4253 return (name === "defaults" ? $.extend({}, $.datepicker._defaults) :
4254 (inst ? (name === "all" ? $.extend({}, inst.settings) :
4255 this._get(inst, name)) : null));
4256 }
4257
4258 settings = name || {};
4259 if (typeof name === "string") {
4260 settings = {};
4261 settings[name] = value;
4262 }
4263
4264 if (inst) {
4265 if (this._curInst === inst) {
4266 this._hideDatepicker();
4267 }
4268
4269 date = this._getDateDatepicker(target, true);
4270 minDate = this._getMinMaxDate(inst, "min");
4271 maxDate = this._getMinMaxDate(inst, "max");
4272 datepicker_extendRemove(inst.settings, settings);
4273 // reformat the old minDate/maxDate values if dateFormat changes and a new minDate/maxDate isn't provided
4274 if (minDate !== null && settings.dateFormat !== undefined && settings.minDate === undefined) {
4275 inst.settings.minDate = this._formatDate(inst, minDate);
4276 }
4277 if (maxDate !== null && settings.dateFormat !== undefined && settings.maxDate === undefined) {
4278 inst.settings.maxDate = this._formatDate(inst, maxDate);
4279 }
4280 if ( "disabled" in settings ) {
4281 if ( settings.disabled ) {
4282 this._disableDatepicker(target);
4283 } else {
4284 this._enableDatepicker(target);
4285 }
4286 }
4287 this._attachments($(target), inst);
4288 this._autoSize(inst);
4289 this._setDate(inst, date);
4290 this._updateAlternate(inst);
4291 this._updateDatepicker(inst);
4292 }
4293 },
4294
4295 // change method deprecated
4296 _changeDatepicker: function(target, name, value) {
4297 this._optionDatepicker(target, name, value);
4298 },
4299
4300 /* Redraw the date picker attached to an input field or division.
4301 * @param target element - the target input field or division or span
4302 */
4303 _refreshDatepicker: function(target) {
4304 var inst = this._getInst(target);
4305 if (inst) {
4306 this._updateDatepicker(inst);
4307 }
4308 },
4309
4310 /* Set the dates for a jQuery selection.
4311 * @param target element - the target input field or division or span
4312 * @param date Date - the new date
4313 */
4314 _setDateDatepicker: function(target, date) {
4315 var inst = this._getInst(target);
4316 if (inst) {
4317 this._setDate(inst, date);
4318 this._updateDatepicker(inst);
4319 this._updateAlternate(inst);
4320 }
4321 },
4322
4323 /* Get the date(s) for the first entry in a jQuery selection.
4324 * @param target element - the target input field or division or span
4325 * @param noDefault boolean - true if no default date is to be used
4326 * @return Date - the current date
4327 */
4328 _getDateDatepicker: function(target, noDefault) {
4329 var inst = this._getInst(target);
4330 if (inst && !inst.inline) {
4331 this._setDateFromField(inst, noDefault);
4332 }
4333 return (inst ? this._getDate(inst) : null);
4334 },
4335
4336 /* Handle keystrokes. */
4337 _doKeyDown: function(event) {
4338 var onSelect, dateStr, sel,
4339 inst = $.datepicker._getInst(event.target),
4340 handled = true,
4341 isRTL = inst.dpDiv.is(".ui-datepicker-rtl");
4342
4343 inst._keyEvent = true;
4344 if ($.datepicker._datepickerShowing) {
4345 switch (event.keyCode) {
4346 case 9: $.datepicker._hideDatepicker();
4347 handled = false;
4348 break; // hide on tab out
4349 case 13: sel = $("td." + $.datepicker._dayOverClass + ":not(." +
4350 $.datepicker._currentClass + ")", inst.dpDiv);
4351 if (sel[0]) {
4352 $.datepicker._selectDay(event.target, inst.selectedMonth, inst.selectedYear, sel[0]);
4353 }
4354
4355 onSelect = $.datepicker._get(inst, "onSelect");
4356 if (onSelect) {
4357 dateStr = $.datepicker._formatDate(inst);
4358
4359 // trigger custom callback
4360 onSelect.apply((inst.input ? inst.input[0] : null), [dateStr, inst]);
4361 } else {
4362 $.datepicker._hideDatepicker();
4363 }
4364
4365 return false; // don't submit the form
4366 case 27: $.datepicker._hideDatepicker();
4367 break; // hide on escape
4368 case 33: $.datepicker._adjustDate(event.target, (event.ctrlKey ?
4369 -$.datepicker._get(inst, "stepBigMonths") :
4370 -$.datepicker._get(inst, "stepMonths")), "M");
4371 break; // previous month/year on page up/+ ctrl
4372 case 34: $.datepicker._adjustDate(event.target, (event.ctrlKey ?
4373 +$.datepicker._get(inst, "stepBigMonths") :
4374 +$.datepicker._get(inst, "stepMonths")), "M");
4375 break; // next month/year on page down/+ ctrl
4376 case 35: if (event.ctrlKey || event.metaKey) {
4377 $.datepicker._clearDate(event.target);
4378 }
4379 handled = event.ctrlKey || event.metaKey;
4380 break; // clear on ctrl or command +end
4381 case 36: if (event.ctrlKey || event.metaKey) {
4382 $.datepicker._gotoToday(event.target);
4383 }
4384 handled = event.ctrlKey || event.metaKey;
4385 break; // current on ctrl or command +home
4386 case 37: if (event.ctrlKey || event.metaKey) {
4387 $.datepicker._adjustDate(event.target, (isRTL ? +1 : -1), "D");
4388 }
4389 handled = event.ctrlKey || event.metaKey;
4390 // -1 day on ctrl or command +left
4391 if (event.originalEvent.altKey) {
4392 $.datepicker._adjustDate(event.target, (event.ctrlKey ?
4393 -$.datepicker._get(inst, "stepBigMonths") :
4394 -$.datepicker._get(inst, "stepMonths")), "M");
4395 }
4396 // next month/year on alt +left on Mac
4397 break;
4398 case 38: if (event.ctrlKey || event.metaKey) {
4399 $.datepicker._adjustDate(event.target, -7, "D");
4400 }
4401 handled = event.ctrlKey || event.metaKey;
4402 break; // -1 week on ctrl or command +up
4403 case 39: if (event.ctrlKey || event.metaKey) {
4404 $.datepicker._adjustDate(event.target, (isRTL ? -1 : +1), "D");
4405 }
4406 handled = event.ctrlKey || event.metaKey;
4407 // +1 day on ctrl or command +right
4408 if (event.originalEvent.altKey) {
4409 $.datepicker._adjustDate(event.target, (event.ctrlKey ?
4410 +$.datepicker._get(inst, "stepBigMonths") :
4411 +$.datepicker._get(inst, "stepMonths")), "M");
4412 }
4413 // next month/year on alt +right
4414 break;
4415 case 40: if (event.ctrlKey || event.metaKey) {
4416 $.datepicker._adjustDate(event.target, +7, "D");
4417 }
4418 handled = event.ctrlKey || event.metaKey;
4419 break; // +1 week on ctrl or command +down
4420 default: handled = false;
4421 }
4422 } else if (event.keyCode === 36 && event.ctrlKey) { // display the date picker on ctrl+home
4423 $.datepicker._showDatepicker(this);
4424 } else {
4425 handled = false;
4426 }
4427
4428 if (handled) {
4429 event.preventDefault();
4430 event.stopPropagation();
4431 }
4432 },
4433
4434 /* Filter entered characters - based on date format. */
4435 _doKeyPress: function(event) {
4436 var chars, chr,
4437 inst = $.datepicker._getInst(event.target);
4438
4439 if ($.datepicker._get(inst, "constrainInput")) {
4440 chars = $.datepicker._possibleChars($.datepicker._get(inst, "dateFormat"));
4441 chr = String.fromCharCode(event.charCode == null ? event.keyCode : event.charCode);
4442 return event.ctrlKey || event.metaKey || (chr < " " || !chars || chars.indexOf(chr) > -1);
4443 }
4444 },
4445
4446 /* Synchronise manual entry and field/alternate field. */
4447 _doKeyUp: function(event) {
4448 var date,
4449 inst = $.datepicker._getInst(event.target);
4450
4451 if (inst.input.val() !== inst.lastVal) {
4452 try {
4453 date = $.datepicker.parseDate($.datepicker._get(inst, "dateFormat"),
4454 (inst.input ? inst.input.val() : null),
4455 $.datepicker._getFormatConfig(inst));
4456
4457 if (date) { // only if valid
4458 $.datepicker._setDateFromField(inst);
4459 $.datepicker._updateAlternate(inst);
4460 $.datepicker._updateDatepicker(inst);
4461 }
4462 }
4463 catch (err) {
4464 }
4465 }
4466 return true;
4467 },
4468
4469 /* Pop-up the date picker for a given input field.
4470 * If false returned from beforeShow event handler do not show.
4471 * @param input element - the input field attached to the date picker or
4472 * event - if triggered by focus
4473 */
4474 _showDatepicker: function(input) {
4475 input = input.target || input;
4476 if (input.nodeName.toLowerCase() !== "input") { // find from button/image trigger
4477 input = $("input", input.parentNode)[0];
4478 }
4479
4480 if ($.datepicker._isDisabledDatepicker(input) || $.datepicker._lastInput === input) { // already here
4481 return;
4482 }
4483
4484 var inst, beforeShow, beforeShowSettings, isFixed,
4485 offset, showAnim, duration;
4486
4487 inst = $.datepicker._getInst(input);
4488 if ($.datepicker._curInst && $.datepicker._curInst !== inst) {
4489 $.datepicker._curInst.dpDiv.stop(true, true);
4490 if ( inst && $.datepicker._datepickerShowing ) {
4491 $.datepicker._hideDatepicker( $.datepicker._curInst.input[0] );
4492 }
4493 }
4494
4495 beforeShow = $.datepicker._get(inst, "beforeShow");
4496 beforeShowSettings = beforeShow ? beforeShow.apply(input, [input, inst]) : {};
4497 if(beforeShowSettings === false){
4498 return;
4499 }
4500 datepicker_extendRemove(inst.settings, beforeShowSettings);
4501
4502 inst.lastVal = null;
4503 $.datepicker._lastInput = input;
4504 $.datepicker._setDateFromField(inst);
4505
4506 if ($.datepicker._inDialog) { // hide cursor
4507 input.value = "";
4508 }
4509 if (!$.datepicker._pos) { // position below input
4510 $.datepicker._pos = $.datepicker._findPos(input);
4511 $.datepicker._pos[1] += input.offsetHeight; // add the height
4512 }
4513
4514 isFixed = false;
4515 $(input).parents().each(function() {
4516 isFixed |= $(this).css("position") === "fixed";
4517 return !isFixed;
4518 });
4519
4520 offset = {left: $.datepicker._pos[0], top: $.datepicker._pos[1]};
4521 $.datepicker._pos = null;
4522 //to avoid flashes on Firefox
4523 inst.dpDiv.empty();
4524 // determine sizing offscreen
4525 inst.dpDiv.css({position: "absolute", display: "block", top: "-1000px"});
4526 $.datepicker._updateDatepicker(inst);
4527 // fix width for dynamic number of date pickers
4528 // and adjust position before showing
4529 offset = $.datepicker._checkOffset(inst, offset, isFixed);
4530 inst.dpDiv.css({position: ($.datepicker._inDialog && $.blockUI ?
4531 "static" : (isFixed ? "fixed" : "absolute")), display: "none",
4532 left: offset.left + "px", top: offset.top + "px"});
4533
4534 if (!inst.inline) {
4535 showAnim = $.datepicker._get(inst, "showAnim");
4536 duration = $.datepicker._get(inst, "duration");
4537 inst.dpDiv.css( "z-index", datepicker_getZindex( $( input ) ) + 1 );
4538 $.datepicker._datepickerShowing = true;
4539
4540 if ( $.effects && $.effects.effect[ showAnim ] ) {
4541 inst.dpDiv.show(showAnim, $.datepicker._get(inst, "showOptions"), duration);
4542 } else {
4543 inst.dpDiv[showAnim || "show"](showAnim ? duration : null);
4544 }
4545
4546 if ( $.datepicker._shouldFocusInput( inst ) ) {
4547 inst.input.focus();
4548 }
4549
4550 $.datepicker._curInst = inst;
4551 }
4552 },
4553
4554 /* Generate the date picker content. */
4555 _updateDatepicker: function(inst) {
4556 this.maxRows = 4; //Reset the max number of rows being displayed (see #7043)
4557 datepicker_instActive = inst; // for delegate hover events
4558 inst.dpDiv.empty().append(this._generateHTML(inst));
4559 this._attachHandlers(inst);
4560
4561 var origyearshtml,
4562 numMonths = this._getNumberOfMonths(inst),
4563 cols = numMonths[1],
4564 width = 17,
4565 activeCell = inst.dpDiv.find( "." + this._dayOverClass + " a" );
4566
4567 if ( activeCell.length > 0 ) {
4568 datepicker_handleMouseover.apply( activeCell.get( 0 ) );
4569 }
4570
4571 inst.dpDiv.removeClass("ui-datepicker-multi-2 ui-datepicker-multi-3 ui-datepicker-multi-4").width("");
4572 if (cols > 1) {
4573 inst.dpDiv.addClass("ui-datepicker-multi-" + cols).css("width", (width * cols) + "em");
4574 }
4575 inst.dpDiv[(numMonths[0] !== 1 || numMonths[1] !== 1 ? "add" : "remove") +
4576 "Class"]("ui-datepicker-multi");
4577 inst.dpDiv[(this._get(inst, "isRTL") ? "add" : "remove") +
4578 "Class"]("ui-datepicker-rtl");
4579
4580 if (inst === $.datepicker._curInst && $.datepicker._datepickerShowing && $.datepicker._shouldFocusInput( inst ) ) {
4581 inst.input.focus();
4582 }
4583
4584 // deffered render of the years select (to avoid flashes on Firefox)
4585 if( inst.yearshtml ){
4586 origyearshtml = inst.yearshtml;
4587 setTimeout(function(){
4588 //assure that inst.yearshtml didn't change.
4589 if( origyearshtml === inst.yearshtml && inst.yearshtml ){
4590 inst.dpDiv.find("select.ui-datepicker-year:first").replaceWith(inst.yearshtml);
4591 }
4592 origyearshtml = inst.yearshtml = null;
4593 }, 0);
4594 }
4595 },
4596
4597 // #6694 - don't focus the input if it's already focused
4598 // this breaks the change event in IE
4599 // Support: IE and jQuery <1.9
4600 _shouldFocusInput: function( inst ) {
4601 return inst.input && inst.input.is( ":visible" ) && !inst.input.is( ":disabled" ) && !inst.input.is( ":focus" );
4602 },
4603
4604 /* Check positioning to remain on screen. */
4605 _checkOffset: function(inst, offset, isFixed) {
4606 var dpWidth = inst.dpDiv.outerWidth(),
4607 dpHeight = inst.dpDiv.outerHeight(),
4608 inputWidth = inst.input ? inst.input.outerWidth() : 0,
4609 inputHeight = inst.input ? inst.input.outerHeight() : 0,
4610 viewWidth = document.documentElement.clientWidth + (isFixed ? 0 : $(document).scrollLeft()),
4611 viewHeight = document.documentElement.clientHeight + (isFixed ? 0 : $(document).scrollTop());
4612
4613 offset.left -= (this._get(inst, "isRTL") ? (dpWidth - inputWidth) : 0);
4614 offset.left -= (isFixed && offset.left === inst.input.offset().left) ? $(document).scrollLeft() : 0;
4615 offset.top -= (isFixed && offset.top === (inst.input.offset().top + inputHeight)) ? $(document).scrollTop() : 0;
4616
4617 // now check if datepicker is showing outside window viewport - move to a better place if so.
4618 offset.left -= Math.min(offset.left, (offset.left + dpWidth > viewWidth && viewWidth > dpWidth) ?
4619 Math.abs(offset.left + dpWidth - viewWidth) : 0);
4620 offset.top -= Math.min(offset.top, (offset.top + dpHeight > viewHeight && viewHeight > dpHeight) ?
4621 Math.abs(dpHeight + inputHeight) : 0);
4622
4623 return offset;
4624 },
4625
4626 /* Find an object's position on the screen. */
4627 _findPos: function(obj) {
4628 var position,
4629 inst = this._getInst(obj),
4630 isRTL = this._get(inst, "isRTL");
4631
4632 while (obj && (obj.type === "hidden" || obj.nodeType !== 1 || $.expr.filters.hidden(obj))) {
4633 obj = obj[isRTL ? "previousSibling" : "nextSibling"];
4634 }
4635
4636 position = $(obj).offset();
4637 return [position.left, position.top];
4638 },
4639
4640 /* Hide the date picker from view.
4641 * @param input element - the input field attached to the date picker
4642 */
4643 _hideDatepicker: function(input) {
4644 var showAnim, duration, postProcess, onClose,
4645 inst = this._curInst;
4646
4647 if (!inst || (input && inst !== $.data(input, "datepicker"))) {
4648 return;
4649 }
4650
4651 if (this._datepickerShowing) {
4652 showAnim = this._get(inst, "showAnim");
4653 duration = this._get(inst, "duration");
4654 postProcess = function() {
4655 $.datepicker._tidyDialog(inst);
4656 };
4657
4658 // DEPRECATED: after BC for 1.8.x $.effects[ showAnim ] is not needed
4659 if ( $.effects && ( $.effects.effect[ showAnim ] || $.effects[ showAnim ] ) ) {
4660 inst.dpDiv.hide(showAnim, $.datepicker._get(inst, "showOptions"), duration, postProcess);
4661 } else {
4662 inst.dpDiv[(showAnim === "slideDown" ? "slideUp" :
4663 (showAnim === "fadeIn" ? "fadeOut" : "hide"))]((showAnim ? duration : null), postProcess);
4664 }
4665
4666 if (!showAnim) {
4667 postProcess();
4668 }
4669 this._datepickerShowing = false;
4670
4671 onClose = this._get(inst, "onClose");
4672 if (onClose) {
4673 onClose.apply((inst.input ? inst.input[0] : null), [(inst.input ? inst.input.val() : ""), inst]);
4674 }
4675
4676 this._lastInput = null;
4677 if (this._inDialog) {
4678 this._dialogInput.css({ position: "absolute", left: "0", top: "-100px" });
4679 if ($.blockUI) {
4680 $.unblockUI();
4681 $("body").append(this.dpDiv);
4682 }
4683 }
4684 this._inDialog = false;
4685 }
4686 },
4687
4688 /* Tidy up after a dialog display. */
4689 _tidyDialog: function(inst) {
4690 inst.dpDiv.removeClass(this._dialogClass).unbind(".ui-datepicker-calendar");
4691 },
4692
4693 /* Close date picker if clicked elsewhere. */
4694 _checkExternalClick: function(event) {
4695 if (!$.datepicker._curInst) {
4696 return;
4697 }
4698
4699 var $target = $(event.target),
4700 inst = $.datepicker._getInst($target[0]);
4701
4702 if ( ( ( $target[0].id !== $.datepicker._mainDivId &&
4703 $target.parents("#" + $.datepicker._mainDivId).length === 0 &&
4704 !$target.hasClass($.datepicker.markerClassName) &&
4705 !$target.closest("." + $.datepicker._triggerClass).length &&
4706 $.datepicker._datepickerShowing && !($.datepicker._inDialog && $.blockUI) ) ) ||
4707 ( $target.hasClass($.datepicker.markerClassName) && $.datepicker._curInst !== inst ) ) {
4708 $.datepicker._hideDatepicker();
4709 }
4710 },
4711
4712 /* Adjust one of the date sub-fields. */
4713 _adjustDate: function(id, offset, period) {
4714 var target = $(id),
4715 inst = this._getInst(target[0]);
4716
4717 if (this._isDisabledDatepicker(target[0])) {
4718 return;
4719 }
4720 this._adjustInstDate(inst, offset +
4721 (period === "M" ? this._get(inst, "showCurrentAtPos") : 0), // undo positioning
4722 period);
4723 this._updateDatepicker(inst);
4724 },
4725
4726 /* Action for current link. */
4727 _gotoToday: function(id) {
4728 var date,
4729 target = $(id),
4730 inst = this._getInst(target[0]);
4731
4732 if (this._get(inst, "gotoCurrent") && inst.currentDay) {
4733 inst.selectedDay = inst.currentDay;
4734 inst.drawMonth = inst.selectedMonth = inst.currentMonth;
4735 inst.drawYear = inst.selectedYear = inst.currentYear;
4736 } else {
4737 date = new Date();
4738 inst.selectedDay = date.getDate();
4739 inst.drawMonth = inst.selectedMonth = date.getMonth();
4740 inst.drawYear = inst.selectedYear = date.getFullYear();
4741 }
4742 this._notifyChange(inst);
4743 this._adjustDate(target);
4744 },
4745
4746 /* Action for selecting a new month/year. */
4747 _selectMonthYear: function(id, select, period) {
4748 var target = $(id),
4749 inst = this._getInst(target[0]);
4750
4751 inst["selected" + (period === "M" ? "Month" : "Year")] =
4752 inst["draw" + (period === "M" ? "Month" : "Year")] =
4753 parseInt(select.options[select.selectedIndex].value,10);
4754
4755 this._notifyChange(inst);
4756 this._adjustDate(target);
4757 },
4758
4759 /* Action for selecting a day. */
4760 _selectDay: function(id, month, year, td) {
4761 var inst,
4762 target = $(id);
4763
4764 if ($(td).hasClass(this._unselectableClass) || this._isDisabledDatepicker(target[0])) {
4765 return;
4766 }
4767
4768 inst = this._getInst(target[0]);
4769 inst.selectedDay = inst.currentDay = $("a", td).html();
4770 inst.selectedMonth = inst.currentMonth = month;
4771 inst.selectedYear = inst.currentYear = year;
4772 this._selectDate(id, this._formatDate(inst,
4773 inst.currentDay, inst.currentMonth, inst.currentYear));
4774 },
4775
4776 /* Erase the input field and hide the date picker. */
4777 _clearDate: function(id) {
4778 var target = $(id);
4779 this._selectDate(target, "");
4780 },
4781
4782 /* Update the input field with the selected date. */
4783 _selectDate: function(id, dateStr) {
4784 var onSelect,
4785 target = $(id),
4786 inst = this._getInst(target[0]);
4787
4788 dateStr = (dateStr != null ? dateStr : this._formatDate(inst));
4789 if (inst.input) {
4790 inst.input.val(dateStr);
4791 }
4792 this._updateAlternate(inst);
4793
4794 onSelect = this._get(inst, "onSelect");
4795 if (onSelect) {
4796 onSelect.apply((inst.input ? inst.input[0] : null), [dateStr, inst]); // trigger custom callback
4797 } else if (inst.input) {
4798 inst.input.trigger("change"); // fire the change event
4799 }
4800
4801 if (inst.inline){
4802 this._updateDatepicker(inst);
4803 } else {
4804 this._hideDatepicker();
4805 this._lastInput = inst.input[0];
4806 if (typeof(inst.input[0]) !== "object") {
4807 inst.input.focus(); // restore focus
4808 }
4809 this._lastInput = null;
4810 }
4811 },
4812
4813 /* Update any alternate field to synchronise with the main field. */
4814 _updateAlternate: function(inst) {
4815 var altFormat, date, dateStr,
4816 altField = this._get(inst, "altField");
4817
4818 if (altField) { // update alternate field too
4819 altFormat = this._get(inst, "altFormat") || this._get(inst, "dateFormat");
4820 date = this._getDate(inst);
4821 dateStr = this.formatDate(altFormat, date, this._getFormatConfig(inst));
4822 $(altField).each(function() { $(this).val(dateStr); });
4823 }
4824 },
4825
4826 /* Set as beforeShowDay function to prevent selection of weekends.
4827 * @param date Date - the date to customise
4828 * @return [boolean, string] - is this date selectable?, what is its CSS class?
4829 */
4830 noWeekends: function(date) {
4831 var day = date.getDay();
4832 return [(day > 0 && day < 6), ""];
4833 },
4834
4835 /* Set as calculateWeek to determine the week of the year based on the ISO 8601 definition.
4836 * @param date Date - the date to get the week for
4837 * @return number - the number of the week within the year that contains this date
4838 */
4839 iso8601Week: function(date) {
4840 var time,
4841 checkDate = new Date(date.getTime());
4842
4843 // Find Thursday of this week starting on Monday
4844 checkDate.setDate(checkDate.getDate() + 4 - (checkDate.getDay() || 7));
4845
4846 time = checkDate.getTime();
4847 checkDate.setMonth(0); // Compare with Jan 1
4848 checkDate.setDate(1);
4849 return Math.floor(Math.round((time - checkDate) / 86400000) / 7) + 1;
4850 },
4851
4852 /* Parse a string value into a date object.
4853 * See formatDate below for the possible formats.
4854 *
4855 * @param format string - the expected format of the date
4856 * @param value string - the date in the above format
4857 * @param settings Object - attributes include:
4858 * shortYearCutoff number - the cutoff year for determining the century (optional)
4859 * dayNamesShort string[7] - abbreviated names of the days from Sunday (optional)
4860 * dayNames string[7] - names of the days from Sunday (optional)
4861 * monthNamesShort string[12] - abbreviated names of the months (optional)
4862 * monthNames string[12] - names of the months (optional)
4863 * @return Date - the extracted date value or null if value is blank
4864 */
4865 parseDate: function (format, value, settings) {
4866 if (format == null || value == null) {
4867 throw "Invalid arguments";
4868 }
4869
4870 value = (typeof value === "object" ? value.toString() : value + "");
4871 if (value === "") {
4872 return null;
4873 }
4874
4875 var iFormat, dim, extra,
4876 iValue = 0,
4877 shortYearCutoffTemp = (settings ? settings.shortYearCutoff : null) || this._defaults.shortYearCutoff,
4878 shortYearCutoff = (typeof shortYearCutoffTemp !== "string" ? shortYearCutoffTemp :
4879 new Date().getFullYear() % 100 + parseInt(shortYearCutoffTemp, 10)),
4880 dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort,
4881 dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames,
4882 monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort,
4883 monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames,
4884 year = -1,
4885 month = -1,
4886 day = -1,
4887 doy = -1,
4888 literal = false,
4889 date,
4890 // Check whether a format character is doubled
4891 lookAhead = function(match) {
4892 var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
4893 if (matches) {
4894 iFormat++;
4895 }
4896 return matches;
4897 },
4898 // Extract a number from the string value
4899 getNumber = function(match) {
4900 var isDoubled = lookAhead(match),
4901 size = (match === "@" ? 14 : (match === "!" ? 20 :
4902 (match === "y" && isDoubled ? 4 : (match === "o" ? 3 : 2)))),
4903 minSize = (match === "y" ? size : 1),
4904 digits = new RegExp("^\\d{" + minSize + "," + size + "}"),
4905 num = value.substring(iValue).match(digits);
4906 if (!num) {
4907 throw "Missing number at position " + iValue;
4908 }
4909 iValue += num[0].length;
4910 return parseInt(num[0], 10);
4911 },
4912 // Extract a name from the string value and convert to an index
4913 getName = function(match, shortNames, longNames) {
4914 var index = -1,
4915 names = $.map(lookAhead(match) ? longNames : shortNames, function (v, k) {
4916 return [ [k, v] ];
4917 }).sort(function (a, b) {
4918 return -(a[1].length - b[1].length);
4919 });
4920
4921 $.each(names, function (i, pair) {
4922 var name = pair[1];
4923 if (value.substr(iValue, name.length).toLowerCase() === name.toLowerCase()) {
4924 index = pair[0];
4925 iValue += name.length;
4926 return false;
4927 }
4928 });
4929 if (index !== -1) {
4930 return index + 1;
4931 } else {
4932 throw "Unknown name at position " + iValue;
4933 }
4934 },
4935 // Confirm that a literal character matches the string value
4936 checkLiteral = function() {
4937 if (value.charAt(iValue) !== format.charAt(iFormat)) {
4938 throw "Unexpected literal at position " + iValue;
4939 }
4940 iValue++;
4941 };
4942
4943 for (iFormat = 0; iFormat < format.length; iFormat++) {
4944 if (literal) {
4945 if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
4946 literal = false;
4947 } else {
4948 checkLiteral();
4949 }
4950 } else {
4951 switch (format.charAt(iFormat)) {
4952 case "d":
4953 day = getNumber("d");
4954 break;
4955 case "D":
4956 getName("D", dayNamesShort, dayNames);
4957 break;
4958 case "o":
4959 doy = getNumber("o");
4960 break;
4961 case "m":
4962 month = getNumber("m");
4963 break;
4964 case "M":
4965 month = getName("M", monthNamesShort, monthNames);
4966 break;
4967 case "y":
4968 year = getNumber("y");
4969 break;
4970 case "@":
4971 date = new Date(getNumber("@"));
4972 year = date.getFullYear();
4973 month = date.getMonth() + 1;
4974 day = date.getDate();
4975 break;
4976 case "!":
4977 date = new Date((getNumber("!") - this._ticksTo1970) / 10000);
4978 year = date.getFullYear();
4979 month = date.getMonth() + 1;
4980 day = date.getDate();
4981 break;
4982 case "'":
4983 if (lookAhead("'")){
4984 checkLiteral();
4985 } else {
4986 literal = true;
4987 }
4988 break;
4989 default:
4990 checkLiteral();
4991 }
4992 }
4993 }
4994
4995 if (iValue < value.length){
4996 extra = value.substr(iValue);
4997 if (!/^\s+/.test(extra)) {
4998 throw "Extra/unparsed characters found in date: " + extra;
4999 }
5000 }
5001
5002 if (year === -1) {
5003 year = new Date().getFullYear();
5004 } else if (year < 100) {
5005 year += new Date().getFullYear() - new Date().getFullYear() % 100 +
5006 (year <= shortYearCutoff ? 0 : -100);
5007 }
5008
5009 if (doy > -1) {
5010 month = 1;
5011 day = doy;
5012 do {
5013 dim = this._getDaysInMonth(year, month - 1);
5014 if (day <= dim) {
5015 break;
5016 }
5017 month++;
5018 day -= dim;
5019 } while (true);
5020 }
5021
5022 date = this._daylightSavingAdjust(new Date(year, month - 1, day));
5023 if (date.getFullYear() !== year || date.getMonth() + 1 !== month || date.getDate() !== day) {
5024 throw "Invalid date"; // E.g. 31/02/00
5025 }
5026 return date;
5027 },
5028
5029 /* Standard date formats. */
5030 ATOM: "yy-mm-dd", // RFC 3339 (ISO 8601)
5031 COOKIE: "D, dd M yy",
5032 ISO_8601: "yy-mm-dd",
5033 RFC_822: "D, d M y",
5034 RFC_850: "DD, dd-M-y",
5035 RFC_1036: "D, d M y",
5036 RFC_1123: "D, d M yy",
5037 RFC_2822: "D, d M yy",
5038 RSS: "D, d M y", // RFC 822
5039 TICKS: "!",
5040 TIMESTAMP: "@",
5041 W3C: "yy-mm-dd", // ISO 8601
5042
5043 _ticksTo1970: (((1970 - 1) * 365 + Math.floor(1970 / 4) - Math.floor(1970 / 100) +
5044 Math.floor(1970 / 400)) * 24 * 60 * 60 * 10000000),
5045
5046 /* Format a date object into a string value.
5047 * The format can be combinations of the following:
5048 * d - day of month (no leading zero)
5049 * dd - day of month (two digit)
5050 * o - day of year (no leading zeros)
5051 * oo - day of year (three digit)
5052 * D - day name short
5053 * DD - day name long
5054 * m - month of year (no leading zero)
5055 * mm - month of year (two digit)
5056 * M - month name short
5057 * MM - month name long
5058 * y - year (two digit)
5059 * yy - year (four digit)
5060 * @ - Unix timestamp (ms since 01/01/1970)
5061 * ! - Windows ticks (100ns since 01/01/0001)
5062 * "..." - literal text
5063 * '' - single quote
5064 *
5065 * @param format string - the desired format of the date
5066 * @param date Date - the date value to format
5067 * @param settings Object - attributes include:
5068 * dayNamesShort string[7] - abbreviated names of the days from Sunday (optional)
5069 * dayNames string[7] - names of the days from Sunday (optional)
5070 * monthNamesShort string[12] - abbreviated names of the months (optional)
5071 * monthNames string[12] - names of the months (optional)
5072 * @return string - the date in the above format
5073 */
5074 formatDate: function (format, date, settings) {
5075 if (!date) {
5076 return "";
5077 }
5078
5079 var iFormat,
5080 dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort,
5081 dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames,
5082 monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort,
5083 monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames,
5084 // Check whether a format character is doubled
5085 lookAhead = function(match) {
5086 var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
5087 if (matches) {
5088 iFormat++;
5089 }
5090 return matches;
5091 },
5092 // Format a number, with leading zero if necessary
5093 formatNumber = function(match, value, len) {
5094 var num = "" + value;
5095 if (lookAhead(match)) {
5096 while (num.length < len) {
5097 num = "0" + num;
5098 }
5099 }
5100 return num;
5101 },
5102 // Format a name, short or long as requested
5103 formatName = function(match, value, shortNames, longNames) {
5104 return (lookAhead(match) ? longNames[value] : shortNames[value]);
5105 },
5106 output = "",
5107 literal = false;
5108
5109 if (date) {
5110 for (iFormat = 0; iFormat < format.length; iFormat++) {
5111 if (literal) {
5112 if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
5113 literal = false;
5114 } else {
5115 output += format.charAt(iFormat);
5116 }
5117 } else {
5118 switch (format.charAt(iFormat)) {
5119 case "d":
5120 output += formatNumber("d", date.getDate(), 2);
5121 break;
5122 case "D":
5123 output += formatName("D", date.getDay(), dayNamesShort, dayNames);
5124 break;
5125 case "o":
5126 output += formatNumber("o",
5127 Math.round((new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime() - new Date(date.getFullYear(), 0, 0).getTime()) / 86400000), 3);
5128 break;
5129 case "m":
5130 output += formatNumber("m", date.getMonth() + 1, 2);
5131 break;
5132 case "M":
5133 output += formatName("M", date.getMonth(), monthNamesShort, monthNames);
5134 break;
5135 case "y":
5136 output += (lookAhead("y") ? date.getFullYear() :
5137 (date.getYear() % 100 < 10 ? "0" : "") + date.getYear() % 100);
5138 break;
5139 case "@":
5140 output += date.getTime();
5141 break;
5142 case "!":
5143 output += date.getTime() * 10000 + this._ticksTo1970;
5144 break;
5145 case "'":
5146 if (lookAhead("'")) {
5147 output += "'";
5148 } else {
5149 literal = true;
5150 }
5151 break;
5152 default:
5153 output += format.charAt(iFormat);
5154 }
5155 }
5156 }
5157 }
5158 return output;
5159 },
5160
5161 /* Extract all possible characters from the date format. */
5162 _possibleChars: function (format) {
5163 var iFormat,
5164 chars = "",
5165 literal = false,
5166 // Check whether a format character is doubled
5167 lookAhead = function(match) {
5168 var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
5169 if (matches) {
5170 iFormat++;
5171 }
5172 return matches;
5173 };
5174
5175 for (iFormat = 0; iFormat < format.length; iFormat++) {
5176 if (literal) {
5177 if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
5178 literal = false;
5179 } else {
5180 chars += format.charAt(iFormat);
5181 }
5182 } else {
5183 switch (format.charAt(iFormat)) {
5184 case "d": case "m": case "y": case "@":
5185 chars += "0123456789";
5186 break;
5187 case "D": case "M":
5188 return null; // Accept anything
5189 case "'":
5190 if (lookAhead("'")) {
5191 chars += "'";
5192 } else {
5193 literal = true;
5194 }
5195 break;
5196 default:
5197 chars += format.charAt(iFormat);
5198 }
5199 }
5200 }
5201 return chars;
5202 },
5203
5204 /* Get a setting value, defaulting if necessary. */
5205 _get: function(inst, name) {
5206 return inst.settings[name] !== undefined ?
5207 inst.settings[name] : this._defaults[name];
5208 },
5209
5210 /* Parse existing date and initialise date picker. */
5211 _setDateFromField: function(inst, noDefault) {
5212 if (inst.input.val() === inst.lastVal) {
5213 return;
5214 }
5215
5216 var dateFormat = this._get(inst, "dateFormat"),
5217 dates = inst.lastVal = inst.input ? inst.input.val() : null,
5218 defaultDate = this._getDefaultDate(inst),
5219 date = defaultDate,
5220 settings = this._getFormatConfig(inst);
5221
5222 try {
5223 date = this.parseDate(dateFormat, dates, settings) || defaultDate;
5224 } catch (event) {
5225 dates = (noDefault ? "" : dates);
5226 }
5227 inst.selectedDay = date.getDate();
5228 inst.drawMonth = inst.selectedMonth = date.getMonth();
5229 inst.drawYear = inst.selectedYear = date.getFullYear();
5230 inst.currentDay = (dates ? date.getDate() : 0);
5231 inst.currentMonth = (dates ? date.getMonth() : 0);
5232 inst.currentYear = (dates ? date.getFullYear() : 0);
5233 this._adjustInstDate(inst);
5234 },
5235
5236 /* Retrieve the default date shown on opening. */
5237 _getDefaultDate: function(inst) {
5238 return this._restrictMinMax(inst,
5239 this._determineDate(inst, this._get(inst, "defaultDate"), new Date()));
5240 },
5241
5242 /* A date may be specified as an exact value or a relative one. */
5243 _determineDate: function(inst, date, defaultDate) {
5244 var offsetNumeric = function(offset) {
5245 var date = new Date();
5246 date.setDate(date.getDate() + offset);
5247 return date;
5248 },
5249 offsetString = function(offset) {
5250 try {
5251 return $.datepicker.parseDate($.datepicker._get(inst, "dateFormat"),
5252 offset, $.datepicker._getFormatConfig(inst));
5253 }
5254 catch (e) {
5255 // Ignore
5256 }
5257
5258 var date = (offset.toLowerCase().match(/^c/) ?
5259 $.datepicker._getDate(inst) : null) || new Date(),
5260 year = date.getFullYear(),
5261 month = date.getMonth(),
5262 day = date.getDate(),
5263 pattern = /([+\-]?[0-9]+)\s*(d|D|w|W|m|M|y|Y)?/g,
5264 matches = pattern.exec(offset);
5265
5266 while (matches) {
5267 switch (matches[2] || "d") {
5268 case "d" : case "D" :
5269 day += parseInt(matches[1],10); break;
5270 case "w" : case "W" :
5271 day += parseInt(matches[1],10) * 7; break;
5272 case "m" : case "M" :
5273 month += parseInt(matches[1],10);
5274 day = Math.min(day, $.datepicker._getDaysInMonth(year, month));
5275 break;
5276 case "y": case "Y" :
5277 year += parseInt(matches[1],10);
5278 day = Math.min(day, $.datepicker._getDaysInMonth(year, month));
5279 break;
5280 }
5281 matches = pattern.exec(offset);
5282 }
5283 return new Date(year, month, day);
5284 },
5285 newDate = (date == null || date === "" ? defaultDate : (typeof date === "string" ? offsetString(date) :
5286 (typeof date === "number" ? (isNaN(date) ? defaultDate : offsetNumeric(date)) : new Date(date.getTime()))));
5287
5288 newDate = (newDate && newDate.toString() === "Invalid Date" ? defaultDate : newDate);
5289 if (newDate) {
5290 newDate.setHours(0);
5291 newDate.setMinutes(0);
5292 newDate.setSeconds(0);
5293 newDate.setMilliseconds(0);
5294 }
5295 return this._daylightSavingAdjust(newDate);
5296 },
5297
5298 /* Handle switch to/from daylight saving.
5299 * Hours may be non-zero on daylight saving cut-over:
5300 * > 12 when midnight changeover, but then cannot generate
5301 * midnight datetime, so jump to 1AM, otherwise reset.
5302 * @param date (Date) the date to check
5303 * @return (Date) the corrected date
5304 */
5305 _daylightSavingAdjust: function(date) {
5306 if (!date) {
5307 return null;
5308 }
5309 date.setHours(date.getHours() > 12 ? date.getHours() + 2 : 0);
5310 return date;
5311 },
5312
5313 /* Set the date(s) directly. */
5314 _setDate: function(inst, date, noChange) {
5315 var clear = !date,
5316 origMonth = inst.selectedMonth,
5317 origYear = inst.selectedYear,
5318 newDate = this._restrictMinMax(inst, this._determineDate(inst, date, new Date()));
5319
5320 inst.selectedDay = inst.currentDay = newDate.getDate();
5321 inst.drawMonth = inst.selectedMonth = inst.currentMonth = newDate.getMonth();
5322 inst.drawYear = inst.selectedYear = inst.currentYear = newDate.getFullYear();
5323 if ((origMonth !== inst.selectedMonth || origYear !== inst.selectedYear) && !noChange) {
5324 this._notifyChange(inst);
5325 }
5326 this._adjustInstDate(inst);
5327 if (inst.input) {
5328 inst.input.val(clear ? "" : this._formatDate(inst));
5329 }
5330 },
5331
5332 /* Retrieve the date(s) directly. */
5333 _getDate: function(inst) {
5334 var startDate = (!inst.currentYear || (inst.input && inst.input.val() === "") ? null :
5335 this._daylightSavingAdjust(new Date(
5336 inst.currentYear, inst.currentMonth, inst.currentDay)));
5337 return startDate;
5338 },
5339
5340 /* Attach the onxxx handlers. These are declared statically so
5341 * they work with static code transformers like Caja.
5342 */
5343 _attachHandlers: function(inst) {
5344 var stepMonths = this._get(inst, "stepMonths"),
5345 id = "#" + inst.id.replace( /\\\\/g, "\\" );
5346 inst.dpDiv.find("[data-handler]").map(function () {
5347 var handler = {
5348 prev: function () {
5349 $.datepicker._adjustDate(id, -stepMonths, "M");
5350 },
5351 next: function () {
5352 $.datepicker._adjustDate(id, +stepMonths, "M");
5353 },
5354 hide: function () {
5355 $.datepicker._hideDatepicker();
5356 },
5357 today: function () {
5358 $.datepicker._gotoToday(id);
5359 },
5360 selectDay: function () {
5361 $.datepicker._selectDay(id, +this.getAttribute("data-month"), +this.getAttribute("data-year"), this);
5362 return false;
5363 },
5364 selectMonth: function () {
5365 $.datepicker._selectMonthYear(id, this, "M");
5366 return false;
5367 },
5368 selectYear: function () {
5369 $.datepicker._selectMonthYear(id, this, "Y");
5370 return false;
5371 }
5372 };
5373 $(this).bind(this.getAttribute("data-event"), handler[this.getAttribute("data-handler")]);
5374 });
5375 },
5376
5377 /* Generate the HTML for the current state of the date picker. */
5378 _generateHTML: function(inst) {
5379 var maxDraw, prevText, prev, nextText, next, currentText, gotoDate,
5380 controls, buttonPanel, firstDay, showWeek, dayNames, dayNamesMin,
5381 monthNames, monthNamesShort, beforeShowDay, showOtherMonths,
5382 selectOtherMonths, defaultDate, html, dow, row, group, col, selectedDate,
5383 cornerClass, calender, thead, day, daysInMonth, leadDays, curRows, numRows,
5384 printDate, dRow, tbody, daySettings, otherMonth, unselectable,
5385 tempDate = new Date(),
5386 today = this._daylightSavingAdjust(
5387 new Date(tempDate.getFullYear(), tempDate.getMonth(), tempDate.getDate())), // clear time
5388 isRTL = this._get(inst, "isRTL"),
5389 showButtonPanel = this._get(inst, "showButtonPanel"),
5390 hideIfNoPrevNext = this._get(inst, "hideIfNoPrevNext"),
5391 navigationAsDateFormat = this._get(inst, "navigationAsDateFormat"),
5392 numMonths = this._getNumberOfMonths(inst),
5393 showCurrentAtPos = this._get(inst, "showCurrentAtPos"),
5394 stepMonths = this._get(inst, "stepMonths"),
5395 isMultiMonth = (numMonths[0] !== 1 || numMonths[1] !== 1),
5396 currentDate = this._daylightSavingAdjust((!inst.currentDay ? new Date(9999, 9, 9) :
5397 new Date(inst.currentYear, inst.currentMonth, inst.currentDay))),
5398 minDate = this._getMinMaxDate(inst, "min"),
5399 maxDate = this._getMinMaxDate(inst, "max"),
5400 drawMonth = inst.drawMonth - showCurrentAtPos,
5401 drawYear = inst.drawYear;
5402
5403 if (drawMonth < 0) {
5404 drawMonth += 12;
5405 drawYear--;
5406 }
5407 if (maxDate) {
5408 maxDraw = this._daylightSavingAdjust(new Date(maxDate.getFullYear(),
5409 maxDate.getMonth() - (numMonths[0] * numMonths[1]) + 1, maxDate.getDate()));
5410 maxDraw = (minDate && maxDraw < minDate ? minDate : maxDraw);
5411 while (this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1)) > maxDraw) {
5412 drawMonth--;
5413 if (drawMonth < 0) {
5414 drawMonth = 11;
5415 drawYear--;
5416 }
5417 }
5418 }
5419 inst.drawMonth = drawMonth;
5420 inst.drawYear = drawYear;
5421
5422 prevText = this._get(inst, "prevText");
5423 prevText = (!navigationAsDateFormat ? prevText : this.formatDate(prevText,
5424 this._daylightSavingAdjust(new Date(drawYear, drawMonth - stepMonths, 1)),
5425 this._getFormatConfig(inst)));
5426
5427 prev = (this._canAdjustMonth(inst, -1, drawYear, drawMonth) ?
5428 "<a class='ui-datepicker-prev ui-corner-all' data-handler='prev' data-event='click'" +
5429 " title='" + prevText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "e" : "w") + "'>" + prevText + "</span></a>" :
5430 (hideIfNoPrevNext ? "" : "<a class='ui-datepicker-prev ui-corner-all ui-state-disabled' title='"+ prevText +"'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "e" : "w") + "'>" + prevText + "</span></a>"));
5431
5432 nextText = this._get(inst, "nextText");
5433 nextText = (!navigationAsDateFormat ? nextText : this.formatDate(nextText,
5434 this._daylightSavingAdjust(new Date(drawYear, drawMonth + stepMonths, 1)),
5435 this._getFormatConfig(inst)));
5436
5437 next = (this._canAdjustMonth(inst, +1, drawYear, drawMonth) ?
5438 "<a class='ui-datepicker-next ui-corner-all' data-handler='next' data-event='click'" +
5439 " title='" + nextText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "w" : "e") + "'>" + nextText + "</span></a>" :
5440 (hideIfNoPrevNext ? "" : "<a class='ui-datepicker-next ui-corner-all ui-state-disabled' title='"+ nextText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "w" : "e") + "'>" + nextText + "</span></a>"));
5441
5442 currentText = this._get(inst, "currentText");
5443 gotoDate = (this._get(inst, "gotoCurrent") && inst.currentDay ? currentDate : today);
5444 currentText = (!navigationAsDateFormat ? currentText :
5445 this.formatDate(currentText, gotoDate, this._getFormatConfig(inst)));
5446
5447 controls = (!inst.inline ? "<button type='button' class='ui-datepicker-close ui-state-default ui-priority-primary ui-corner-all' data-handler='hide' data-event='click'>" +
5448 this._get(inst, "closeText") + "</button>" : "");
5449
5450 buttonPanel = (showButtonPanel) ? "<div class='ui-datepicker-buttonpane ui-widget-content'>" + (isRTL ? controls : "") +
5451 (this._isInRange(inst, gotoDate) ? "<button type='button' class='ui-datepicker-current ui-state-default ui-priority-secondary ui-corner-all' data-handler='today' data-event='click'" +
5452 ">" + currentText + "</button>" : "") + (isRTL ? "" : controls) + "</div>" : "";
5453
5454 firstDay = parseInt(this._get(inst, "firstDay"),10);
5455 firstDay = (isNaN(firstDay) ? 0 : firstDay);
5456
5457 showWeek = this._get(inst, "showWeek");
5458 dayNames = this._get(inst, "dayNames");
5459 dayNamesMin = this._get(inst, "dayNamesMin");
5460 monthNames = this._get(inst, "monthNames");
5461 monthNamesShort = this._get(inst, "monthNamesShort");
5462 beforeShowDay = this._get(inst, "beforeShowDay");
5463 showOtherMonths = this._get(inst, "showOtherMonths");
5464 selectOtherMonths = this._get(inst, "selectOtherMonths");
5465 defaultDate = this._getDefaultDate(inst);
5466 html = "";
5467 dow;
5468 for (row = 0; row < numMonths[0]; row++) {
5469 group = "";
5470 this.maxRows = 4;
5471 for (col = 0; col < numMonths[1]; col++) {
5472 selectedDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, inst.selectedDay));
5473 cornerClass = " ui-corner-all";
5474 calender = "";
5475 if (isMultiMonth) {
5476 calender += "<div class='ui-datepicker-group";
5477 if (numMonths[1] > 1) {
5478 switch (col) {
5479 case 0: calender += " ui-datepicker-group-first";
5480 cornerClass = " ui-corner-" + (isRTL ? "right" : "left"); break;
5481 case numMonths[1]-1: calender += " ui-datepicker-group-last";
5482 cornerClass = " ui-corner-" + (isRTL ? "left" : "right"); break;
5483 default: calender += " ui-datepicker-group-middle"; cornerClass = ""; break;
5484 }
5485 }
5486 calender += "'>";
5487 }
5488 calender += "<div class='ui-datepicker-header ui-widget-header ui-helper-clearfix" + cornerClass + "'>" +
5489 (/all|left/.test(cornerClass) && row === 0 ? (isRTL ? next : prev) : "") +
5490 (/all|right/.test(cornerClass) && row === 0 ? (isRTL ? prev : next) : "") +
5491 this._generateMonthYearHeader(inst, drawMonth, drawYear, minDate, maxDate,
5492 row > 0 || col > 0, monthNames, monthNamesShort) + // draw month headers
5493 "</div><table class='ui-datepicker-calendar'><thead>" +
5494 "<tr>";
5495 thead = (showWeek ? "<th class='ui-datepicker-week-col'>" + this._get(inst, "weekHeader") + "</th>" : "");
5496 for (dow = 0; dow < 7; dow++) { // days of the week
5497 day = (dow + firstDay) % 7;
5498 thead += "<th scope='col'" + ((dow + firstDay + 6) % 7 >= 5 ? " class='ui-datepicker-week-end'" : "") + ">" +
5499 "<span title='" + dayNames[day] + "'>" + dayNamesMin[day] + "</span></th>";
5500 }
5501 calender += thead + "</tr></thead><tbody>";
5502 daysInMonth = this._getDaysInMonth(drawYear, drawMonth);
5503 if (drawYear === inst.selectedYear && drawMonth === inst.selectedMonth) {
5504 inst.selectedDay = Math.min(inst.selectedDay, daysInMonth);
5505 }
5506 leadDays = (this._getFirstDayOfMonth(drawYear, drawMonth) - firstDay + 7) % 7;
5507 curRows = Math.ceil((leadDays + daysInMonth) / 7); // calculate the number of rows to generate
5508 numRows = (isMultiMonth ? this.maxRows > curRows ? this.maxRows : curRows : curRows); //If multiple months, use the higher number of rows (see #7043)
5509 this.maxRows = numRows;
5510 printDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1 - leadDays));
5511 for (dRow = 0; dRow < numRows; dRow++) { // create date picker rows
5512 calender += "<tr>";
5513 tbody = (!showWeek ? "" : "<td class='ui-datepicker-week-col'>" +
5514 this._get(inst, "calculateWeek")(printDate) + "</td>");
5515 for (dow = 0; dow < 7; dow++) { // create date picker days
5516 daySettings = (beforeShowDay ?
5517 beforeShowDay.apply((inst.input ? inst.input[0] : null), [printDate]) : [true, ""]);
5518 otherMonth = (printDate.getMonth() !== drawMonth);
5519 unselectable = (otherMonth && !selectOtherMonths) || !daySettings[0] ||
5520 (minDate && printDate < minDate) || (maxDate && printDate > maxDate);
5521 tbody += "<td class='" +
5522 ((dow + firstDay + 6) % 7 >= 5 ? " ui-datepicker-week-end" : "") + // highlight weekends
5523 (otherMonth ? " ui-datepicker-other-month" : "") + // highlight days from other months
5524 ((printDate.getTime() === selectedDate.getTime() && drawMonth === inst.selectedMonth && inst._keyEvent) || // user pressed key
5525 (defaultDate.getTime() === printDate.getTime() && defaultDate.getTime() === selectedDate.getTime()) ?
5526 // or defaultDate is current printedDate and defaultDate is selectedDate
5527 " " + this._dayOverClass : "") + // highlight selected day
5528 (unselectable ? " " + this._unselectableClass + " ui-state-disabled": "") + // highlight unselectable days
5529 (otherMonth && !showOtherMonths ? "" : " " + daySettings[1] + // highlight custom dates
5530 (printDate.getTime() === currentDate.getTime() ? " " + this._currentClass : "") + // highlight selected day
5531 (printDate.getTime() === today.getTime() ? " ui-datepicker-today" : "")) + "'" + // highlight today (if different)
5532 ((!otherMonth || showOtherMonths) && daySettings[2] ? " title='" + daySettings[2].replace(/'/g, "'") + "'" : "") + // cell title
5533 (unselectable ? "" : " data-handler='selectDay' data-event='click' data-month='" + printDate.getMonth() + "' data-year='" + printDate.getFullYear() + "'") + ">" + // actions
5534 (otherMonth && !showOtherMonths ? " " : // display for other months
5535 (unselectable ? "<span class='ui-state-default'>" + printDate.getDate() + "</span>" : "<a class='ui-state-default" +
5536 (printDate.getTime() === today.getTime() ? " ui-state-highlight" : "") +
5537 (printDate.getTime() === currentDate.getTime() ? " ui-state-active" : "") + // highlight selected day
5538 (otherMonth ? " ui-priority-secondary" : "") + // distinguish dates from other months
5539 "' href='#'>" + printDate.getDate() + "</a>")) + "</td>"; // display selectable date
5540 printDate.setDate(printDate.getDate() + 1);
5541 printDate = this._daylightSavingAdjust(printDate);
5542 }
5543 calender += tbody + "</tr>";
5544 }
5545 drawMonth++;
5546 if (drawMonth > 11) {
5547 drawMonth = 0;
5548 drawYear++;
5549 }
5550 calender += "</tbody></table>" + (isMultiMonth ? "</div>" +
5551 ((numMonths[0] > 0 && col === numMonths[1]-1) ? "<div class='ui-datepicker-row-break'></div>" : "") : "");
5552 group += calender;
5553 }
5554 html += group;
5555 }
5556 html += buttonPanel;
5557 inst._keyEvent = false;
5558 return html;
5559 },
5560
5561 /* Generate the month and year header. */
5562 _generateMonthYearHeader: function(inst, drawMonth, drawYear, minDate, maxDate,
5563 secondary, monthNames, monthNamesShort) {
5564
5565 var inMinYear, inMaxYear, month, years, thisYear, determineYear, year, endYear,
5566 changeMonth = this._get(inst, "changeMonth"),
5567 changeYear = this._get(inst, "changeYear"),
5568 showMonthAfterYear = this._get(inst, "showMonthAfterYear"),
5569 html = "<div class='ui-datepicker-title'>",
5570 monthHtml = "";
5571
5572 // month selection
5573 if (secondary || !changeMonth) {
5574 monthHtml += "<span class='ui-datepicker-month'>" + monthNames[drawMonth] + "</span>";
5575 } else {
5576 inMinYear = (minDate && minDate.getFullYear() === drawYear);
5577 inMaxYear = (maxDate && maxDate.getFullYear() === drawYear);
5578 monthHtml += "<select class='ui-datepicker-month' data-handler='selectMonth' data-event='change'>";
5579 for ( month = 0; month < 12; month++) {
5580 if ((!inMinYear || month >= minDate.getMonth()) && (!inMaxYear || month <= maxDate.getMonth())) {
5581 monthHtml += "<option value='" + month + "'" +
5582 (month === drawMonth ? " selected='selected'" : "") +
5583 ">" + monthNamesShort[month] + "</option>";
5584 }
5585 }
5586 monthHtml += "</select>";
5587 }
5588
5589 if (!showMonthAfterYear) {
5590 html += monthHtml + (secondary || !(changeMonth && changeYear) ? " " : "");
5591 }
5592
5593 // year selection
5594 if ( !inst.yearshtml ) {
5595 inst.yearshtml = "";
5596 if (secondary || !changeYear) {
5597 html += "<span class='ui-datepicker-year'>" + drawYear + "</span>";
5598 } else {
5599 // determine range of years to display
5600 years = this._get(inst, "yearRange").split(":");
5601 thisYear = new Date().getFullYear();
5602 determineYear = function(value) {
5603 var year = (value.match(/c[+\-].*/) ? drawYear + parseInt(value.substring(1), 10) :
5604 (value.match(/[+\-].*/) ? thisYear + parseInt(value, 10) :
5605 parseInt(value, 10)));
5606 return (isNaN(year) ? thisYear : year);
5607 };
5608 year = determineYear(years[0]);
5609 endYear = Math.max(year, determineYear(years[1] || ""));
5610 year = (minDate ? Math.max(year, minDate.getFullYear()) : year);
5611 endYear = (maxDate ? Math.min(endYear, maxDate.getFullYear()) : endYear);
5612 inst.yearshtml += "<select class='ui-datepicker-year' data-handler='selectYear' data-event='change'>";
5613 for (; year <= endYear; year++) {
5614 inst.yearshtml += "<option value='" + year + "'" +
5615 (year === drawYear ? " selected='selected'" : "") +
5616 ">" + year + "</option>";
5617 }
5618 inst.yearshtml += "</select>";
5619
5620 html += inst.yearshtml;
5621 inst.yearshtml = null;
5622 }
5623 }
5624
5625 html += this._get(inst, "yearSuffix");
5626 if (showMonthAfterYear) {
5627 html += (secondary || !(changeMonth && changeYear) ? " " : "") + monthHtml;
5628 }
5629 html += "</div>"; // Close datepicker_header
5630 return html;
5631 },
5632
5633 /* Adjust one of the date sub-fields. */
5634 _adjustInstDate: function(inst, offset, period) {
5635 var year = inst.drawYear + (period === "Y" ? offset : 0),
5636 month = inst.drawMonth + (period === "M" ? offset : 0),
5637 day = Math.min(inst.selectedDay, this._getDaysInMonth(year, month)) + (period === "D" ? offset : 0),
5638 date = this._restrictMinMax(inst, this._daylightSavingAdjust(new Date(year, month, day)));
5639
5640 inst.selectedDay = date.getDate();
5641 inst.drawMonth = inst.selectedMonth = date.getMonth();
5642 inst.drawYear = inst.selectedYear = date.getFullYear();
5643 if (period === "M" || period === "Y") {
5644 this._notifyChange(inst);
5645 }
5646 },
5647
5648 /* Ensure a date is within any min/max bounds. */
5649 _restrictMinMax: function(inst, date) {
5650 var minDate = this._getMinMaxDate(inst, "min"),
5651 maxDate = this._getMinMaxDate(inst, "max"),
5652 newDate = (minDate && date < minDate ? minDate : date);
5653 return (maxDate && newDate > maxDate ? maxDate : newDate);
5654 },
5655
5656 /* Notify change of month/year. */
5657 _notifyChange: function(inst) {
5658 var onChange = this._get(inst, "onChangeMonthYear");
5659 if (onChange) {
5660 onChange.apply((inst.input ? inst.input[0] : null),
5661 [inst.selectedYear, inst.selectedMonth + 1, inst]);
5662 }
5663 },
5664
5665 /* Determine the number of months to show. */
5666 _getNumberOfMonths: function(inst) {
5667 var numMonths = this._get(inst, "numberOfMonths");
5668 return (numMonths == null ? [1, 1] : (typeof numMonths === "number" ? [1, numMonths] : numMonths));
5669 },
5670
5671 /* Determine the current maximum date - ensure no time components are set. */
5672 _getMinMaxDate: function(inst, minMax) {
5673 return this._determineDate(inst, this._get(inst, minMax + "Date"), null);
5674 },
5675
5676 /* Find the number of days in a given month. */
5677 _getDaysInMonth: function(year, month) {
5678 return 32 - this._daylightSavingAdjust(new Date(year, month, 32)).getDate();
5679 },
5680
5681 /* Find the day of the week of the first of a month. */
5682 _getFirstDayOfMonth: function(year, month) {
5683 return new Date(year, month, 1).getDay();
5684 },
5685
5686 /* Determines if we should allow a "next/prev" month display change. */
5687 _canAdjustMonth: function(inst, offset, curYear, curMonth) {
5688 var numMonths = this._getNumberOfMonths(inst),
5689 date = this._daylightSavingAdjust(new Date(curYear,
5690 curMonth + (offset < 0 ? offset : numMonths[0] * numMonths[1]), 1));
5691
5692 if (offset < 0) {
5693 date.setDate(this._getDaysInMonth(date.getFullYear(), date.getMonth()));
5694 }
5695 return this._isInRange(inst, date);
5696 },
5697
5698 /* Is the given date in the accepted range? */
5699 _isInRange: function(inst, date) {
5700 var yearSplit, currentYear,
5701 minDate = this._getMinMaxDate(inst, "min"),
5702 maxDate = this._getMinMaxDate(inst, "max"),
5703 minYear = null,
5704 maxYear = null,
5705 years = this._get(inst, "yearRange");
5706 if (years){
5707 yearSplit = years.split(":");
5708 currentYear = new Date().getFullYear();
5709 minYear = parseInt(yearSplit[0], 10);
5710 maxYear = parseInt(yearSplit[1], 10);
5711 if ( yearSplit[0].match(/[+\-].*/) ) {
5712 minYear += currentYear;
5713 }
5714 if ( yearSplit[1].match(/[+\-].*/) ) {
5715 maxYear += currentYear;
5716 }
5717 }
5718
5719 return ((!minDate || date.getTime() >= minDate.getTime()) &&
5720 (!maxDate || date.getTime() <= maxDate.getTime()) &&
5721 (!minYear || date.getFullYear() >= minYear) &&
5722 (!maxYear || date.getFullYear() <= maxYear));
5723 },
5724
5725 /* Provide the configuration settings for formatting/parsing. */
5726 _getFormatConfig: function(inst) {
5727 var shortYearCutoff = this._get(inst, "shortYearCutoff");
5728 shortYearCutoff = (typeof shortYearCutoff !== "string" ? shortYearCutoff :
5729 new Date().getFullYear() % 100 + parseInt(shortYearCutoff, 10));
5730 return {shortYearCutoff: shortYearCutoff,
5731 dayNamesShort: this._get(inst, "dayNamesShort"), dayNames: this._get(inst, "dayNames"),
5732 monthNamesShort: this._get(inst, "monthNamesShort"), monthNames: this._get(inst, "monthNames")};
5733 },
5734
5735 /* Format the given date for display. */
5736 _formatDate: function(inst, day, month, year) {
5737 if (!day) {
5738 inst.currentDay = inst.selectedDay;
5739 inst.currentMonth = inst.selectedMonth;
5740 inst.currentYear = inst.selectedYear;
5741 }
5742 var date = (day ? (typeof day === "object" ? day :
5743 this._daylightSavingAdjust(new Date(year, month, day))) :
5744 this._daylightSavingAdjust(new Date(inst.currentYear, inst.currentMonth, inst.currentDay)));
5745 return this.formatDate(this._get(inst, "dateFormat"), date, this._getFormatConfig(inst));
5746 }
5747 });
5748
5749 /*
5750 * Bind hover events for datepicker elements.
5751 * Done via delegate so the binding only occurs once in the lifetime of the parent div.
5752 * Global datepicker_instActive, set by _updateDatepicker allows the handlers to find their way back to the active picker.
5753 */
5754 function datepicker_bindHover(dpDiv) {
5755 var selector = "button, .ui-datepicker-prev, .ui-datepicker-next, .ui-datepicker-calendar td a";
5756 return dpDiv.delegate(selector, "mouseout", function() {
5757 $(this).removeClass("ui-state-hover");
5758 if (this.className.indexOf("ui-datepicker-prev") !== -1) {
5759 $(this).removeClass("ui-datepicker-prev-hover");
5760 }
5761 if (this.className.indexOf("ui-datepicker-next") !== -1) {
5762 $(this).removeClass("ui-datepicker-next-hover");
5763 }
5764 })
5765 .delegate( selector, "mouseover", datepicker_handleMouseover );
5766 }
5767
5768 function datepicker_handleMouseover() {
5769 if (!$.datepicker._isDisabledDatepicker( datepicker_instActive.inline? datepicker_instActive.dpDiv.parent()[0] : datepicker_instActive.input[0])) {
5770 $(this).parents(".ui-datepicker-calendar").find("a").removeClass("ui-state-hover");
5771 $(this).addClass("ui-state-hover");
5772 if (this.className.indexOf("ui-datepicker-prev") !== -1) {
5773 $(this).addClass("ui-datepicker-prev-hover");
5774 }
5775 if (this.className.indexOf("ui-datepicker-next") !== -1) {
5776 $(this).addClass("ui-datepicker-next-hover");
5777 }
5778 }
5779 }
5780
5781 /* jQuery extend now ignores nulls! */
5782 function datepicker_extendRemove(target, props) {
5783 $.extend(target, props);
5784 for (var name in props) {
5785 if (props[name] == null) {
5786 target[name] = props[name];
5787 }
5788 }
5789 return target;
5790 }
5791
5792 /* Invoke the datepicker functionality.
5793 @param options string - a command, optionally followed by additional parameters or
5794 Object - settings for attaching new datepicker functionality
5795 @return jQuery object */
5796 $.fn.datepicker = function(options){
5797
5798 /* Verify an empty collection wasn't passed - Fixes #6976 */
5799 if ( !this.length ) {
5800 return this;
5801 }
5802
5803 /* Initialise the date picker. */
5804 if (!$.datepicker.initialized) {
5805 $(document).mousedown($.datepicker._checkExternalClick);
5806 $.datepicker.initialized = true;
5807 }
5808
5809 /* Append datepicker main container to body if not exist. */
5810 if ($("#"+$.datepicker._mainDivId).length === 0) {
5811 $("body").append($.datepicker.dpDiv);
5812 }
5813
5814 var otherArgs = Array.prototype.slice.call(arguments, 1);
5815 if (typeof options === "string" && (options === "isDisabled" || options === "getDate" || options === "widget")) {
5816 return $.datepicker["_" + options + "Datepicker"].
5817 apply($.datepicker, [this[0]].concat(otherArgs));
5818 }
5819 if (options === "option" && arguments.length === 2 && typeof arguments[1] === "string") {
5820 return $.datepicker["_" + options + "Datepicker"].
5821 apply($.datepicker, [this[0]].concat(otherArgs));
5822 }
5823 return this.each(function() {
5824 typeof options === "string" ?
5825 $.datepicker["_" + options + "Datepicker"].
5826 apply($.datepicker, [this].concat(otherArgs)) :
5827 $.datepicker._attachDatepicker(this, options);
5828 });
5829 };
5830
5831 $.datepicker = new Datepicker(); // singleton instance
5832 $.datepicker.initialized = false;
5833 $.datepicker.uuid = new Date().getTime();
5834 $.datepicker.version = "1.11.4";
5835
5836 var datepicker = $.datepicker;
5837
5838
5839 /*!
5840 * jQuery UI Draggable 1.11.4
5841 * http://jqueryui.com
5842 *
5843 * Copyright jQuery Foundation and other contributors
5844 * Released under the MIT license.
5845 * http://jquery.org/license
5846 *
5847 * http://api.jqueryui.com/draggable/
5848 */
5849
5850
5851 $.widget("ui.draggable", $.ui.mouse, {
5852 version: "1.11.4",
5853 widgetEventPrefix: "drag",
5854 options: {
5855 addClasses: true,
5856 appendTo: "parent",
5857 axis: false,
5858 connectToSortable: false,
5859 containment: false,
5860 cursor: "auto",
5861 cursorAt: false,
5862 grid: false,
5863 handle: false,
5864 helper: "original",
5865 iframeFix: false,
5866 opacity: false,
5867 refreshPositions: false,
5868 revert: false,
5869 revertDuration: 500,
5870 scope: "default",
5871 scroll: true,
5872 scrollSensitivity: 20,
5873 scrollSpeed: 20,
5874 snap: false,
5875 snapMode: "both",
5876 snapTolerance: 20,
5877 stack: false,
5878 zIndex: false,
5879
5880 // callbacks
5881 drag: null,
5882 start: null,
5883 stop: null
5884 },
5885 _create: function() {
5886
5887 if ( this.options.helper === "original" ) {
5888 this._setPositionRelative();
5889 }
5890 if (this.options.addClasses){
5891 this.element.addClass("ui-draggable");
5892 }
5893 if (this.options.disabled){
5894 this.element.addClass("ui-draggable-disabled");
5895 }
5896 this._setHandleClassName();
5897
5898 this._mouseInit();
5899 },
5900
5901 _setOption: function( key, value ) {
5902 this._super( key, value );
5903 if ( key === "handle" ) {
5904 this._removeHandleClassName();
5905 this._setHandleClassName();
5906 }
5907 },
5908
5909 _destroy: function() {
5910 if ( ( this.helper || this.element ).is( ".ui-draggable-dragging" ) ) {
5911 this.destroyOnClear = true;
5912 return;
5913 }
5914 this.element.removeClass( "ui-draggable ui-draggable-dragging ui-draggable-disabled" );
5915 this._removeHandleClassName();
5916 this._mouseDestroy();
5917 },
5918
5919 _mouseCapture: function(event) {
5920 var o = this.options;
5921
5922 this._blurActiveElement( event );
5923
5924 // among others, prevent a drag on a resizable-handle
5925 if (this.helper || o.disabled || $(event.target).closest(".ui-resizable-handle").length > 0) {
5926 return false;
5927 }
5928
5929 //Quit if we're not on a valid handle
5930 this.handle = this._getHandle(event);
5931 if (!this.handle) {
5932 return false;
5933 }
5934
5935 this._blockFrames( o.iframeFix === true ? "iframe" : o.iframeFix );
5936
5937 return true;
5938
5939 },
5940
5941 _blockFrames: function( selector ) {
5942 this.iframeBlocks = this.document.find( selector ).map(function() {
5943 var iframe = $( this );
5944
5945 return $( "<div>" )
5946 .css( "position", "absolute" )
5947 .appendTo( iframe.parent() )
5948 .outerWidth( iframe.outerWidth() )
5949 .outerHeight( iframe.outerHeight() )
5950 .offset( iframe.offset() )[ 0 ];
5951 });
5952 },
5953
5954 _unblockFrames: function() {
5955 if ( this.iframeBlocks ) {
5956 this.iframeBlocks.remove();
5957 delete this.iframeBlocks;
5958 }
5959 },
5960
5961 _blurActiveElement: function( event ) {
5962 var document = this.document[ 0 ];
5963
5964 // Only need to blur if the event occurred on the draggable itself, see #10527
5965 if ( !this.handleElement.is( event.target ) ) {
5966 return;
5967 }
5968
5969 // support: IE9
5970 // IE9 throws an "Unspecified error" accessing document.activeElement from an <iframe>
5971 try {
5972
5973 // Support: IE9, IE10
5974 // If the <body> is blurred, IE will switch windows, see #9520
5975 if ( document.activeElement && document.activeElement.nodeName.toLowerCase() !== "body" ) {
5976
5977 // Blur any element that currently has focus, see #4261
5978 $( document.activeElement ).blur();
5979 }
5980 } catch ( error ) {}
5981 },
5982
5983 _mouseStart: function(event) {
5984
5985 var o = this.options;
5986
5987 //Create and append the visible helper
5988 this.helper = this._createHelper(event);
5989
5990 this.helper.addClass("ui-draggable-dragging");
5991
5992 //Cache the helper size
5993 this._cacheHelperProportions();
5994
5995 //If ddmanager is used for droppables, set the global draggable
5996 if ($.ui.ddmanager) {
5997 $.ui.ddmanager.current = this;
5998 }
5999
6000 /*
6001 * - Position generation -
6002 * This block generates everything position related - it's the core of draggables.
6003 */
6004
6005 //Cache the margins of the original element
6006 this._cacheMargins();
6007
6008 //Store the helper's css position
6009 this.cssPosition = this.helper.css( "position" );
6010 this.scrollParent = this.helper.scrollParent( true );
6011 this.offsetParent = this.helper.offsetParent();
6012 this.hasFixedAncestor = this.helper.parents().filter(function() {
6013 return $( this ).css( "position" ) === "fixed";
6014 }).length > 0;
6015
6016 //The element's absolute position on the page minus margins
6017 this.positionAbs = this.element.offset();
6018 this._refreshOffsets( event );
6019
6020 //Generate the original position
6021 this.originalPosition = this.position = this._generatePosition( event, false );
6022 this.originalPageX = event.pageX;
6023 this.originalPageY = event.pageY;
6024
6025 //Adjust the mouse offset relative to the helper if "cursorAt" is supplied
6026 (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
6027
6028 //Set a containment if given in the options
6029 this._setContainment();
6030
6031 //Trigger event + callbacks
6032 if (this._trigger("start", event) === false) {
6033 this._clear();
6034 return false;
6035 }
6036
6037 //Recache the helper size
6038 this._cacheHelperProportions();
6039
6040 //Prepare the droppable offsets
6041 if ($.ui.ddmanager && !o.dropBehaviour) {
6042 $.ui.ddmanager.prepareOffsets(this, event);
6043 }
6044
6045 // Reset helper's right/bottom css if they're set and set explicit width/height instead
6046 // as this prevents resizing of elements with right/bottom set (see #7772)
6047 this._normalizeRightBottom();
6048
6049 this._mouseDrag(event, true); //Execute the drag once - this causes the helper not to be visible before getting its correct position
6050
6051 //If the ddmanager is used for droppables, inform the manager that dragging has started (see #5003)
6052 if ( $.ui.ddmanager ) {
6053 $.ui.ddmanager.dragStart(this, event);
6054 }
6055
6056 return true;
6057 },
6058
6059 _refreshOffsets: function( event ) {
6060 this.offset = {
6061 top: this.positionAbs.top - this.margins.top,
6062 left: this.positionAbs.left - this.margins.left,
6063 scroll: false,
6064 parent: this._getParentOffset(),
6065 relative: this._getRelativeOffset()
6066 };
6067
6068 this.offset.click = {
6069 left: event.pageX - this.offset.left,
6070 top: event.pageY - this.offset.top
6071 };
6072 },
6073
6074 _mouseDrag: function(event, noPropagation) {
6075 // reset any necessary cached properties (see #5009)
6076 if ( this.hasFixedAncestor ) {
6077 this.offset.parent = this._getParentOffset();
6078 }
6079
6080 //Compute the helpers position
6081 this.position = this._generatePosition( event, true );
6082 this.positionAbs = this._convertPositionTo("absolute");
6083
6084 //Call plugins and callbacks and use the resulting position if something is returned
6085 if (!noPropagation) {
6086 var ui = this._uiHash();
6087 if (this._trigger("drag", event, ui) === false) {
6088 this._mouseUp({});
6089 return false;
6090 }
6091 this.position = ui.position;
6092 }
6093
6094 this.helper[ 0 ].style.left = this.position.left + "px";
6095 this.helper[ 0 ].style.top = this.position.top + "px";
6096
6097 if ($.ui.ddmanager) {
6098 $.ui.ddmanager.drag(this, event);
6099 }
6100
6101 return false;
6102 },
6103
6104 _mouseStop: function(event) {
6105
6106 //If we are using droppables, inform the manager about the drop
6107 var that = this,
6108 dropped = false;
6109 if ($.ui.ddmanager && !this.options.dropBehaviour) {
6110 dropped = $.ui.ddmanager.drop(this, event);
6111 }
6112
6113 //if a drop comes from outside (a sortable)
6114 if (this.dropped) {
6115 dropped = this.dropped;
6116 this.dropped = false;
6117 }
6118
6119 if ((this.options.revert === "invalid" && !dropped) || (this.options.revert === "valid" && dropped) || this.options.revert === true || ($.isFunction(this.options.revert) && this.options.revert.call(this.element, dropped))) {
6120 $(this.helper).animate(this.originalPosition, parseInt(this.options.revertDuration, 10), function() {
6121 if (that._trigger("stop", event) !== false) {
6122 that._clear();
6123 }
6124 });
6125 } else {
6126 if (this._trigger("stop", event) !== false) {
6127 this._clear();
6128 }
6129 }
6130
6131 return false;
6132 },
6133
6134 _mouseUp: function( event ) {
6135 this._unblockFrames();
6136
6137 //If the ddmanager is used for droppables, inform the manager that dragging has stopped (see #5003)
6138 if ( $.ui.ddmanager ) {
6139 $.ui.ddmanager.dragStop(this, event);
6140 }
6141
6142 // Only need to focus if the event occurred on the draggable itself, see #10527
6143 if ( this.handleElement.is( event.target ) ) {
6144 // The interaction is over; whether or not the click resulted in a drag, focus the element
6145 this.element.focus();
6146 }
6147
6148 return $.ui.mouse.prototype._mouseUp.call(this, event);
6149 },
6150
6151 cancel: function() {
6152
6153 if (this.helper.is(".ui-draggable-dragging")) {
6154 this._mouseUp({});
6155 } else {
6156 this._clear();
6157 }
6158
6159 return this;
6160
6161 },
6162
6163 _getHandle: function(event) {
6164 return this.options.handle ?
6165 !!$( event.target ).closest( this.element.find( this.options.handle ) ).length :
6166 true;
6167 },
6168
6169 _setHandleClassName: function() {
6170 this.handleElement = this.options.handle ?
6171 this.element.find( this.options.handle ) : this.element;
6172 this.handleElement.addClass( "ui-draggable-handle" );
6173 },
6174
6175 _removeHandleClassName: function() {
6176 this.handleElement.removeClass( "ui-draggable-handle" );
6177 },
6178
6179 _createHelper: function(event) {
6180
6181 var o = this.options,
6182 helperIsFunction = $.isFunction( o.helper ),
6183 helper = helperIsFunction ?
6184 $( o.helper.apply( this.element[ 0 ], [ event ] ) ) :
6185 ( o.helper === "clone" ?
6186 this.element.clone().removeAttr( "id" ) :
6187 this.element );
6188
6189 if (!helper.parents("body").length) {
6190 helper.appendTo((o.appendTo === "parent" ? this.element[0].parentNode : o.appendTo));
6191 }
6192
6193 // http://bugs.jqueryui.com/ticket/9446
6194 // a helper function can return the original element
6195 // which wouldn't have been set to relative in _create
6196 if ( helperIsFunction && helper[ 0 ] === this.element[ 0 ] ) {
6197 this._setPositionRelative();
6198 }
6199
6200 if (helper[0] !== this.element[0] && !(/(fixed|absolute)/).test(helper.css("position"))) {
6201 helper.css("position", "absolute");
6202 }
6203
6204 return helper;
6205
6206 },
6207
6208 _setPositionRelative: function() {
6209 if ( !( /^(?:r|a|f)/ ).test( this.element.css( "position" ) ) ) {
6210 this.element[ 0 ].style.position = "relative";
6211 }
6212 },
6213
6214 _adjustOffsetFromHelper: function(obj) {
6215 if (typeof obj === "string") {
6216 obj = obj.split(" ");
6217 }
6218 if ($.isArray(obj)) {
6219 obj = { left: +obj[0], top: +obj[1] || 0 };
6220 }
6221 if ("left" in obj) {
6222 this.offset.click.left = obj.left + this.margins.left;
6223 }
6224 if ("right" in obj) {
6225 this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
6226 }
6227 if ("top" in obj) {
6228 this.offset.click.top = obj.top + this.margins.top;
6229 }
6230 if ("bottom" in obj) {
6231 this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
6232 }
6233 },
6234
6235 _isRootNode: function( element ) {
6236 return ( /(html|body)/i ).test( element.tagName ) || element === this.document[ 0 ];
6237 },
6238
6239 _getParentOffset: function() {
6240
6241 //Get the offsetParent and cache its position
6242 var po = this.offsetParent.offset(),
6243 document = this.document[ 0 ];
6244
6245 // This is a special case where we need to modify a offset calculated on start, since the following happened:
6246 // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
6247 // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
6248 // the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
6249 if (this.cssPosition === "absolute" && this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) {
6250 po.left += this.scrollParent.scrollLeft();
6251 po.top += this.scrollParent.scrollTop();
6252 }
6253
6254 if ( this._isRootNode( this.offsetParent[ 0 ] ) ) {
6255 po = { top: 0, left: 0 };
6256 }
6257
6258 return {
6259 top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"), 10) || 0),
6260 left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"), 10) || 0)
6261 };
6262
6263 },
6264
6265 _getRelativeOffset: function() {
6266 if ( this.cssPosition !== "relative" ) {
6267 return { top: 0, left: 0 };
6268 }
6269
6270 var p = this.element.position(),
6271 scrollIsRootNode = this._isRootNode( this.scrollParent[ 0 ] );
6272
6273 return {
6274 top: p.top - ( parseInt(this.helper.css( "top" ), 10) || 0 ) + ( !scrollIsRootNode ? this.scrollParent.scrollTop() : 0 ),
6275 left: p.left - ( parseInt(this.helper.css( "left" ), 10) || 0 ) + ( !scrollIsRootNode ? this.scrollParent.scrollLeft() : 0 )
6276 };
6277
6278 },
6279
6280 _cacheMargins: function() {
6281 this.margins = {
6282 left: (parseInt(this.element.css("marginLeft"), 10) || 0),
6283 top: (parseInt(this.element.css("marginTop"), 10) || 0),
6284 right: (parseInt(this.element.css("marginRight"), 10) || 0),
6285 bottom: (parseInt(this.element.css("marginBottom"), 10) || 0)
6286 };
6287 },
6288
6289 _cacheHelperProportions: function() {
6290 this.helperProportions = {
6291 width: this.helper.outerWidth(),
6292 height: this.helper.outerHeight()
6293 };
6294 },
6295
6296 _setContainment: function() {
6297
6298 var isUserScrollable, c, ce,
6299 o = this.options,
6300 document = this.document[ 0 ];
6301
6302 this.relativeContainer = null;
6303
6304 if ( !o.containment ) {
6305 this.containment = null;
6306 return;
6307 }
6308
6309 if ( o.containment === "window" ) {
6310 this.containment = [
6311 $( window ).scrollLeft() - this.offset.relative.left - this.offset.parent.left,
6312 $( window ).scrollTop() - this.offset.relative.top - this.offset.parent.top,
6313 $( window ).scrollLeft() + $( window ).width() - this.helperProportions.width - this.margins.left,
6314 $( window ).scrollTop() + ( $( window ).height() || document.body.parentNode.scrollHeight ) - this.helperProportions.height - this.margins.top
6315 ];
6316 return;
6317 }
6318
6319 if ( o.containment === "document") {
6320 this.containment = [
6321 0,
6322 0,
6323 $( document ).width() - this.helperProportions.width - this.margins.left,
6324 ( $( document ).height() || document.body.parentNode.scrollHeight ) - this.helperProportions.height - this.margins.top
6325 ];
6326 return;
6327 }
6328
6329 if ( o.containment.constructor === Array ) {
6330 this.containment = o.containment;
6331 return;
6332 }
6333
6334 if ( o.containment === "parent" ) {
6335 o.containment = this.helper[ 0 ].parentNode;
6336 }
6337
6338 c = $( o.containment );
6339 ce = c[ 0 ];
6340
6341 if ( !ce ) {
6342 return;
6343 }
6344
6345 isUserScrollable = /(scroll|auto)/.test( c.css( "overflow" ) );
6346
6347 this.containment = [
6348 ( parseInt( c.css( "borderLeftWidth" ), 10 ) || 0 ) + ( parseInt( c.css( "paddingLeft" ), 10 ) || 0 ),
6349 ( parseInt( c.css( "borderTopWidth" ), 10 ) || 0 ) + ( parseInt( c.css( "paddingTop" ), 10 ) || 0 ),
6350 ( isUserScrollable ? Math.max( ce.scrollWidth, ce.offsetWidth ) : ce.offsetWidth ) -
6351 ( parseInt( c.css( "borderRightWidth" ), 10 ) || 0 ) -
6352 ( parseInt( c.css( "paddingRight" ), 10 ) || 0 ) -
6353 this.helperProportions.width -
6354 this.margins.left -
6355 this.margins.right,
6356 ( isUserScrollable ? Math.max( ce.scrollHeight, ce.offsetHeight ) : ce.offsetHeight ) -
6357 ( parseInt( c.css( "borderBottomWidth" ), 10 ) || 0 ) -
6358 ( parseInt( c.css( "paddingBottom" ), 10 ) || 0 ) -
6359 this.helperProportions.height -
6360 this.margins.top -
6361 this.margins.bottom
6362 ];
6363 this.relativeContainer = c;
6364 },
6365
6366 _convertPositionTo: function(d, pos) {
6367
6368 if (!pos) {
6369 pos = this.position;
6370 }
6371
6372 var mod = d === "absolute" ? 1 : -1,
6373 scrollIsRootNode = this._isRootNode( this.scrollParent[ 0 ] );
6374
6375 return {
6376 top: (
6377 pos.top + // The absolute mouse position
6378 this.offset.relative.top * mod + // Only for relative positioned nodes: Relative offset from element to offset parent
6379 this.offset.parent.top * mod - // The offsetParent's offset without borders (offset + border)
6380 ( ( this.cssPosition === "fixed" ? -this.offset.scroll.top : ( scrollIsRootNode ? 0 : this.offset.scroll.top ) ) * mod)
6381 ),
6382 left: (
6383 pos.left + // The absolute mouse position
6384 this.offset.relative.left * mod + // Only for relative positioned nodes: Relative offset from element to offset parent
6385 this.offset.parent.left * mod - // The offsetParent's offset without borders (offset + border)
6386 ( ( this.cssPosition === "fixed" ? -this.offset.scroll.left : ( scrollIsRootNode ? 0 : this.offset.scroll.left ) ) * mod)
6387 )
6388 };
6389
6390 },
6391
6392 _generatePosition: function( event, constrainPosition ) {
6393
6394 var containment, co, top, left,
6395 o = this.options,
6396 scrollIsRootNode = this._isRootNode( this.scrollParent[ 0 ] ),
6397 pageX = event.pageX,
6398 pageY = event.pageY;
6399
6400 // Cache the scroll
6401 if ( !scrollIsRootNode || !this.offset.scroll ) {
6402 this.offset.scroll = {
6403 top: this.scrollParent.scrollTop(),
6404 left: this.scrollParent.scrollLeft()
6405 };
6406 }
6407
6408 /*
6409 * - Position constraining -
6410 * Constrain the position to a mix of grid, containment.
6411 */
6412
6413 // If we are not dragging yet, we won't check for options
6414 if ( constrainPosition ) {
6415 if ( this.containment ) {
6416 if ( this.relativeContainer ){
6417 co = this.relativeContainer.offset();
6418 containment = [
6419 this.containment[ 0 ] + co.left,
6420 this.containment[ 1 ] + co.top,
6421 this.containment[ 2 ] + co.left,
6422 this.containment[ 3 ] + co.top
6423 ];
6424 } else {
6425 containment = this.containment;
6426 }
6427
6428 if (event.pageX - this.offset.click.left < containment[0]) {
6429 pageX = containment[0] + this.offset.click.left;
6430 }
6431 if (event.pageY - this.offset.click.top < containment[1]) {
6432 pageY = containment[1] + this.offset.click.top;
6433 }
6434 if (event.pageX - this.offset.click.left > containment[2]) {
6435 pageX = containment[2] + this.offset.click.left;
6436 }
6437 if (event.pageY - this.offset.click.top > containment[3]) {
6438 pageY = containment[3] + this.offset.click.top;
6439 }
6440 }
6441
6442 if (o.grid) {
6443 //Check for grid elements set to 0 to prevent divide by 0 error causing invalid argument errors in IE (see ticket #6950)
6444 top = o.grid[1] ? this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1] : this.originalPageY;
6445 pageY = containment ? ((top - this.offset.click.top >= containment[1] || top - this.offset.click.top > containment[3]) ? top : ((top - this.offset.click.top >= containment[1]) ? top - o.grid[1] : top + o.grid[1])) : top;
6446
6447 left = o.grid[0] ? this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0] : this.originalPageX;
6448 pageX = containment ? ((left - this.offset.click.left >= containment[0] || left - this.offset.click.left > containment[2]) ? left : ((left - this.offset.click.left >= containment[0]) ? left - o.grid[0] : left + o.grid[0])) : left;
6449 }
6450
6451 if ( o.axis === "y" ) {
6452 pageX = this.originalPageX;
6453 }
6454
6455 if ( o.axis === "x" ) {
6456 pageY = this.originalPageY;
6457 }
6458 }
6459
6460 return {
6461 top: (
6462 pageY - // The absolute mouse position
6463 this.offset.click.top - // Click offset (relative to the element)
6464 this.offset.relative.top - // Only for relative positioned nodes: Relative offset from element to offset parent
6465 this.offset.parent.top + // The offsetParent's offset without borders (offset + border)
6466 ( this.cssPosition === "fixed" ? -this.offset.scroll.top : ( scrollIsRootNode ? 0 : this.offset.scroll.top ) )
6467 ),
6468 left: (
6469 pageX - // The absolute mouse position
6470 this.offset.click.left - // Click offset (relative to the element)
6471 this.offset.relative.left - // Only for relative positioned nodes: Relative offset from element to offset parent
6472 this.offset.parent.left + // The offsetParent's offset without borders (offset + border)
6473 ( this.cssPosition === "fixed" ? -this.offset.scroll.left : ( scrollIsRootNode ? 0 : this.offset.scroll.left ) )
6474 )
6475 };
6476
6477 },
6478
6479 _clear: function() {
6480 this.helper.removeClass("ui-draggable-dragging");
6481 if (this.helper[0] !== this.element[0] && !this.cancelHelperRemoval) {
6482 this.helper.remove();
6483 }
6484 this.helper = null;
6485 this.cancelHelperRemoval = false;
6486 if ( this.destroyOnClear ) {
6487 this.destroy();
6488 }
6489 },
6490
6491 _normalizeRightBottom: function() {
6492 if ( this.options.axis !== "y" && this.helper.css( "right" ) !== "auto" ) {
6493 this.helper.width( this.helper.width() );
6494 this.helper.css( "right", "auto" );
6495 }
6496 if ( this.options.axis !== "x" && this.helper.css( "bottom" ) !== "auto" ) {
6497 this.helper.height( this.helper.height() );
6498 this.helper.css( "bottom", "auto" );
6499 }
6500 },
6501
6502 // From now on bulk stuff - mainly helpers
6503
6504 _trigger: function( type, event, ui ) {
6505 ui = ui || this._uiHash();
6506 $.ui.plugin.call( this, type, [ event, ui, this ], true );
6507
6508 // Absolute position and offset (see #6884 ) have to be recalculated after plugins
6509 if ( /^(drag|start|stop)/.test( type ) ) {
6510 this.positionAbs = this._convertPositionTo( "absolute" );
6511 ui.offset = this.positionAbs;
6512 }
6513 return $.Widget.prototype._trigger.call( this, type, event, ui );
6514 },
6515
6516 plugins: {},
6517
6518 _uiHash: function() {
6519 return {
6520 helper: this.helper,
6521 position: this.position,
6522 originalPosition: this.originalPosition,
6523 offset: this.positionAbs
6524 };
6525 }
6526
6527 });
6528
6529 $.ui.plugin.add( "draggable", "connectToSortable", {
6530 start: function( event, ui, draggable ) {
6531 var uiSortable = $.extend( {}, ui, {
6532 item: draggable.element
6533 });
6534
6535 draggable.sortables = [];
6536 $( draggable.options.connectToSortable ).each(function() {
6537 var sortable = $( this ).sortable( "instance" );
6538
6539 if ( sortable && !sortable.options.disabled ) {
6540 draggable.sortables.push( sortable );
6541
6542 // refreshPositions is called at drag start to refresh the containerCache
6543 // which is used in drag. This ensures it's initialized and synchronized
6544 // with any changes that might have happened on the page since initialization.
6545 sortable.refreshPositions();
6546 sortable._trigger("activate", event, uiSortable);
6547 }
6548 });
6549 },
6550 stop: function( event, ui, draggable ) {
6551 var uiSortable = $.extend( {}, ui, {
6552 item: draggable.element
6553 });
6554
6555 draggable.cancelHelperRemoval = false;
6556
6557 $.each( draggable.sortables, function() {
6558 var sortable = this;
6559
6560 if ( sortable.isOver ) {
6561 sortable.isOver = 0;
6562
6563 // Allow this sortable to handle removing the helper
6564 draggable.cancelHelperRemoval = true;
6565 sortable.cancelHelperRemoval = false;
6566
6567 // Use _storedCSS To restore properties in the sortable,
6568 // as this also handles revert (#9675) since the draggable
6569 // may have modified them in unexpected ways (#8809)
6570 sortable._storedCSS = {
6571 position: sortable.placeholder.css( "position" ),
6572 top: sortable.placeholder.css( "top" ),
6573 left: sortable.placeholder.css( "left" )
6574 };
6575
6576 sortable._mouseStop(event);
6577
6578 // Once drag has ended, the sortable should return to using
6579 // its original helper, not the shared helper from draggable
6580 sortable.options.helper = sortable.options._helper;
6581 } else {
6582 // Prevent this Sortable from removing the helper.
6583 // However, don't set the draggable to remove the helper
6584 // either as another connected Sortable may yet handle the removal.
6585 sortable.cancelHelperRemoval = true;
6586
6587 sortable._trigger( "deactivate", event, uiSortable );
6588 }
6589 });
6590 },
6591 drag: function( event, ui, draggable ) {
6592 $.each( draggable.sortables, function() {
6593 var innermostIntersecting = false,
6594 sortable = this;
6595
6596 // Copy over variables that sortable's _intersectsWith uses
6597 sortable.positionAbs = draggable.positionAbs;
6598 sortable.helperProportions = draggable.helperProportions;
6599 sortable.offset.click = draggable.offset.click;
6600
6601 if ( sortable._intersectsWith( sortable.containerCache ) ) {
6602 innermostIntersecting = true;
6603
6604 $.each( draggable.sortables, function() {
6605 // Copy over variables that sortable's _intersectsWith uses
6606 this.positionAbs = draggable.positionAbs;
6607 this.helperProportions = draggable.helperProportions;
6608 this.offset.click = draggable.offset.click;
6609
6610 if ( this !== sortable &&
6611 this._intersectsWith( this.containerCache ) &&
6612 $.contains( sortable.element[ 0 ], this.element[ 0 ] ) ) {
6613 innermostIntersecting = false;
6614 }
6615
6616 return innermostIntersecting;
6617 });
6618 }
6619
6620 if ( innermostIntersecting ) {
6621 // If it intersects, we use a little isOver variable and set it once,
6622 // so that the move-in stuff gets fired only once.
6623 if ( !sortable.isOver ) {
6624 sortable.isOver = 1;
6625
6626 // Store draggable's parent in case we need to reappend to it later.
6627 draggable._parent = ui.helper.parent();
6628
6629 sortable.currentItem = ui.helper
6630 .appendTo( sortable.element )
6631 .data( "ui-sortable-item", true );
6632
6633 // Store helper option to later restore it
6634 sortable.options._helper = sortable.options.helper;
6635
6636 sortable.options.helper = function() {
6637 return ui.helper[ 0 ];
6638 };
6639
6640 // Fire the start events of the sortable with our passed browser event,
6641 // and our own helper (so it doesn't create a new one)
6642 event.target = sortable.currentItem[ 0 ];
6643 sortable._mouseCapture( event, true );
6644 sortable._mouseStart( event, true, true );
6645
6646 // Because the browser event is way off the new appended portlet,
6647 // modify necessary variables to reflect the changes
6648 sortable.offset.click.top = draggable.offset.click.top;
6649 sortable.offset.click.left = draggable.offset.click.left;
6650 sortable.offset.parent.left -= draggable.offset.parent.left -
6651 sortable.offset.parent.left;
6652 sortable.offset.parent.top -= draggable.offset.parent.top -
6653 sortable.offset.parent.top;
6654
6655 draggable._trigger( "toSortable", event );
6656
6657 // Inform draggable that the helper is in a valid drop zone,
6658 // used solely in the revert option to handle "valid/invalid".
6659 draggable.dropped = sortable.element;
6660
6661 // Need to refreshPositions of all sortables in the case that
6662 // adding to one sortable changes the location of the other sortables (#9675)
6663 $.each( draggable.sortables, function() {
6664 this.refreshPositions();
6665 });
6666
6667 // hack so receive/update callbacks work (mostly)
6668 draggable.currentItem = draggable.element;
6669 sortable.fromOutside = draggable;
6670 }
6671
6672 if ( sortable.currentItem ) {
6673 sortable._mouseDrag( event );
6674 // Copy the sortable's position because the draggable's can potentially reflect
6675 // a relative position, while sortable is always absolute, which the dragged
6676 // element has now become. (#8809)
6677 ui.position = sortable.position;
6678 }
6679 } else {
6680 // If it doesn't intersect with the sortable, and it intersected before,
6681 // we fake the drag stop of the sortable, but make sure it doesn't remove
6682 // the helper by using cancelHelperRemoval.
6683 if ( sortable.isOver ) {
6684
6685 sortable.isOver = 0;
6686 sortable.cancelHelperRemoval = true;
6687
6688 // Calling sortable's mouseStop would trigger a revert,
6689 // so revert must be temporarily false until after mouseStop is called.
6690 sortable.options._revert = sortable.options.revert;
6691 sortable.options.revert = false;
6692
6693 sortable._trigger( "out", event, sortable._uiHash( sortable ) );
6694 sortable._mouseStop( event, true );
6695
6696 // restore sortable behaviors that were modfied
6697 // when the draggable entered the sortable area (#9481)
6698 sortable.options.revert = sortable.options._revert;
6699 sortable.options.helper = sortable.options._helper;
6700
6701 if ( sortable.placeholder ) {
6702 sortable.placeholder.remove();
6703 }
6704
6705 // Restore and recalculate the draggable's offset considering the sortable
6706 // may have modified them in unexpected ways. (#8809, #10669)
6707 ui.helper.appendTo( draggable._parent );
6708 draggable._refreshOffsets( event );
6709 ui.position = draggable._generatePosition( event, true );
6710
6711 draggable._trigger( "fromSortable", event );
6712
6713 // Inform draggable that the helper is no longer in a valid drop zone
6714 draggable.dropped = false;
6715
6716 // Need to refreshPositions of all sortables just in case removing
6717 // from one sortable changes the location of other sortables (#9675)
6718 $.each( draggable.sortables, function() {
6719 this.refreshPositions();
6720 });
6721 }
6722 }
6723 });
6724 }
6725 });
6726
6727 $.ui.plugin.add("draggable", "cursor", {
6728 start: function( event, ui, instance ) {
6729 var t = $( "body" ),
6730 o = instance.options;
6731
6732 if (t.css("cursor")) {
6733 o._cursor = t.css("cursor");
6734 }
6735 t.css("cursor", o.cursor);
6736 },
6737 stop: function( event, ui, instance ) {
6738 var o = instance.options;
6739 if (o._cursor) {
6740 $("body").css("cursor", o._cursor);
6741 }
6742 }
6743 });
6744
6745 $.ui.plugin.add("draggable", "opacity", {
6746 start: function( event, ui, instance ) {
6747 var t = $( ui.helper ),
6748 o = instance.options;
6749 if (t.css("opacity")) {
6750 o._opacity = t.css("opacity");
6751 }
6752 t.css("opacity", o.opacity);
6753 },
6754 stop: function( event, ui, instance ) {
6755 var o = instance.options;
6756 if (o._opacity) {
6757 $(ui.helper).css("opacity", o._opacity);
6758 }
6759 }
6760 });
6761
6762 $.ui.plugin.add("draggable", "scroll", {
6763 start: function( event, ui, i ) {
6764 if ( !i.scrollParentNotHidden ) {
6765 i.scrollParentNotHidden = i.helper.scrollParent( false );
6766 }
6767
6768 if ( i.scrollParentNotHidden[ 0 ] !== i.document[ 0 ] && i.scrollParentNotHidden[ 0 ].tagName !== "HTML" ) {
6769 i.overflowOffset = i.scrollParentNotHidden.offset();
6770 }
6771 },
6772 drag: function( event, ui, i ) {
6773
6774 var o = i.options,
6775 scrolled = false,
6776 scrollParent = i.scrollParentNotHidden[ 0 ],
6777 document = i.document[ 0 ];
6778
6779 if ( scrollParent !== document && scrollParent.tagName !== "HTML" ) {
6780 if ( !o.axis || o.axis !== "x" ) {
6781 if ( ( i.overflowOffset.top + scrollParent.offsetHeight ) - event.pageY < o.scrollSensitivity ) {
6782 scrollParent.scrollTop = scrolled = scrollParent.scrollTop + o.scrollSpeed;
6783 } else if ( event.pageY - i.overflowOffset.top < o.scrollSensitivity ) {
6784 scrollParent.scrollTop = scrolled = scrollParent.scrollTop - o.scrollSpeed;
6785 }
6786 }
6787
6788 if ( !o.axis || o.axis !== "y" ) {
6789 if ( ( i.overflowOffset.left + scrollParent.offsetWidth ) - event.pageX < o.scrollSensitivity ) {
6790 scrollParent.scrollLeft = scrolled = scrollParent.scrollLeft + o.scrollSpeed;
6791 } else if ( event.pageX - i.overflowOffset.left < o.scrollSensitivity ) {
6792 scrollParent.scrollLeft = scrolled = scrollParent.scrollLeft - o.scrollSpeed;
6793 }
6794 }
6795
6796 } else {
6797
6798 if (!o.axis || o.axis !== "x") {
6799 if (event.pageY - $(document).scrollTop() < o.scrollSensitivity) {
6800 scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
6801 } else if ($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity) {
6802 scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
6803 }
6804 }
6805
6806 if (!o.axis || o.axis !== "y") {
6807 if (event.pageX - $(document).scrollLeft() < o.scrollSensitivity) {
6808 scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
6809 } else if ($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity) {
6810 scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
6811 }
6812 }
6813
6814 }
6815
6816 if (scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
6817 $.ui.ddmanager.prepareOffsets(i, event);
6818 }
6819
6820 }
6821 });
6822
6823 $.ui.plugin.add("draggable", "snap", {
6824 start: function( event, ui, i ) {
6825
6826 var o = i.options;
6827
6828 i.snapElements = [];
6829
6830 $(o.snap.constructor !== String ? ( o.snap.items || ":data(ui-draggable)" ) : o.snap).each(function() {
6831 var $t = $(this),
6832 $o = $t.offset();
6833 if (this !== i.element[0]) {
6834 i.snapElements.push({
6835 item: this,
6836 width: $t.outerWidth(), height: $t.outerHeight(),
6837 top: $o.top, left: $o.left
6838 });
6839 }
6840 });
6841
6842 },
6843 drag: function( event, ui, inst ) {
6844
6845 var ts, bs, ls, rs, l, r, t, b, i, first,
6846 o = inst.options,
6847 d = o.snapTolerance,
6848 x1 = ui.offset.left, x2 = x1 + inst.helperProportions.width,
6849 y1 = ui.offset.top, y2 = y1 + inst.helperProportions.height;
6850
6851 for (i = inst.snapElements.length - 1; i >= 0; i--){
6852
6853 l = inst.snapElements[i].left - inst.margins.left;
6854 r = l + inst.snapElements[i].width;
6855 t = inst.snapElements[i].top - inst.margins.top;
6856 b = t + inst.snapElements[i].height;
6857
6858 if ( x2 < l - d || x1 > r + d || y2 < t - d || y1 > b + d || !$.contains( inst.snapElements[ i ].item.ownerDocument, inst.snapElements[ i ].item ) ) {
6859 if (inst.snapElements[i].snapping) {
6860 (inst.options.snap.release && inst.options.snap.release.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
6861 }
6862 inst.snapElements[i].snapping = false;
6863 continue;
6864 }
6865
6866 if (o.snapMode !== "inner") {
6867 ts = Math.abs(t - y2) <= d;
6868 bs = Math.abs(b - y1) <= d;
6869 ls = Math.abs(l - x2) <= d;
6870 rs = Math.abs(r - x1) <= d;
6871 if (ts) {
6872 ui.position.top = inst._convertPositionTo("relative", { top: t - inst.helperProportions.height, left: 0 }).top;
6873 }
6874 if (bs) {
6875 ui.position.top = inst._convertPositionTo("relative", { top: b, left: 0 }).top;
6876 }
6877 if (ls) {
6878 ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l - inst.helperProportions.width }).left;
6879 }
6880 if (rs) {
6881 ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r }).left;
6882 }
6883 }
6884
6885 first = (ts || bs || ls || rs);
6886
6887 if (o.snapMode !== "outer") {
6888 ts = Math.abs(t - y1) <= d;
6889 bs = Math.abs(b - y2) <= d;
6890 ls = Math.abs(l - x1) <= d;
6891 rs = Math.abs(r - x2) <= d;
6892 if (ts) {
6893 ui.position.top = inst._convertPositionTo("relative", { top: t, left: 0 }).top;
6894 }
6895 if (bs) {
6896 ui.position.top = inst._convertPositionTo("relative", { top: b - inst.helperProportions.height, left: 0 }).top;
6897 }
6898 if (ls) {
6899 ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l }).left;
6900 }
6901 if (rs) {
6902 ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r - inst.helperProportions.width }).left;
6903 }
6904 }
6905
6906 if (!inst.snapElements[i].snapping && (ts || bs || ls || rs || first)) {
6907 (inst.options.snap.snap && inst.options.snap.snap.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
6908 }
6909 inst.snapElements[i].snapping = (ts || bs || ls || rs || first);
6910
6911 }
6912
6913 }
6914 });
6915
6916 $.ui.plugin.add("draggable", "stack", {
6917 start: function( event, ui, instance ) {
6918 var min,
6919 o = instance.options,
6920 group = $.makeArray($(o.stack)).sort(function(a, b) {
6921 return (parseInt($(a).css("zIndex"), 10) || 0) - (parseInt($(b).css("zIndex"), 10) || 0);
6922 });
6923
6924 if (!group.length) { return; }
6925
6926 min = parseInt($(group[0]).css("zIndex"), 10) || 0;
6927 $(group).each(function(i) {
6928 $(this).css("zIndex", min + i);
6929 });
6930 this.css("zIndex", (min + group.length));
6931 }
6932 });
6933
6934 $.ui.plugin.add("draggable", "zIndex", {
6935 start: function( event, ui, instance ) {
6936 var t = $( ui.helper ),
6937 o = instance.options;
6938
6939 if (t.css("zIndex")) {
6940 o._zIndex = t.css("zIndex");
6941 }
6942 t.css("zIndex", o.zIndex);
6943 },
6944 stop: function( event, ui, instance ) {
6945 var o = instance.options;
6946
6947 if (o._zIndex) {
6948 $(ui.helper).css("zIndex", o._zIndex);
6949 }
6950 }
6951 });
6952
6953 var draggable = $.ui.draggable;
6954
6955
6956 /*!
6957 * jQuery UI Resizable 1.11.4
6958 * http://jqueryui.com
6959 *
6960 * Copyright jQuery Foundation and other contributors
6961 * Released under the MIT license.
6962 * http://jquery.org/license
6963 *
6964 * http://api.jqueryui.com/resizable/
6965 */
6966
6967
6968 $.widget("ui.resizable", $.ui.mouse, {
6969 version: "1.11.4",
6970 widgetEventPrefix: "resize",
6971 options: {
6972 alsoResize: false,
6973 animate: false,
6974 animateDuration: "slow",
6975 animateEasing: "swing",
6976 aspectRatio: false,
6977 autoHide: false,
6978 containment: false,
6979 ghost: false,
6980 grid: false,
6981 handles: "e,s,se",
6982 helper: false,
6983 maxHeight: null,
6984 maxWidth: null,
6985 minHeight: 10,
6986 minWidth: 10,
6987 // See #7960
6988 zIndex: 90,
6989
6990 // callbacks
6991 resize: null,
6992 start: null,
6993 stop: null
6994 },
6995
6996 _num: function( value ) {
6997 return parseInt( value, 10 ) || 0;
6998 },
6999
7000 _isNumber: function( value ) {
7001 return !isNaN( parseInt( value, 10 ) );
7002 },
7003
7004 _hasScroll: function( el, a ) {
7005
7006 if ( $( el ).css( "overflow" ) === "hidden") {
7007 return false;
7008 }
7009
7010 var scroll = ( a && a === "left" ) ? "scrollLeft" : "scrollTop",
7011 has = false;
7012
7013 if ( el[ scroll ] > 0 ) {
7014 return true;
7015 }
7016
7017 // TODO: determine which cases actually cause this to happen
7018 // if the element doesn't have the scroll set, see if it's possible to
7019 // set the scroll
7020 el[ scroll ] = 1;
7021 has = ( el[ scroll ] > 0 );
7022 el[ scroll ] = 0;
7023 return has;
7024 },
7025
7026 _create: function() {
7027
7028 var n, i, handle, axis, hname,
7029 that = this,
7030 o = this.options;
7031 this.element.addClass("ui-resizable");
7032
7033 $.extend(this, {
7034 _aspectRatio: !!(o.aspectRatio),
7035 aspectRatio: o.aspectRatio,
7036 originalElement: this.element,
7037 _proportionallyResizeElements: [],
7038 _helper: o.helper || o.ghost || o.animate ? o.helper || "ui-resizable-helper" : null
7039 });
7040
7041 // Wrap the element if it cannot hold child nodes
7042 if (this.element[0].nodeName.match(/^(canvas|textarea|input|select|button|img)$/i)) {
7043
7044 this.element.wrap(
7045 $("<div class='ui-wrapper' style='overflow: hidden;'></div>").css({
7046 position: this.element.css("position"),
7047 width: this.element.outerWidth(),
7048 height: this.element.outerHeight(),
7049 top: this.element.css("top"),
7050 left: this.element.css("left")
7051 })
7052 );
7053
7054 this.element = this.element.parent().data(
7055 "ui-resizable", this.element.resizable( "instance" )
7056 );
7057
7058 this.elementIsWrapper = true;
7059
7060 this.element.css({
7061 marginLeft: this.originalElement.css("marginLeft"),
7062 marginTop: this.originalElement.css("marginTop"),
7063 marginRight: this.originalElement.css("marginRight"),
7064 marginBottom: this.originalElement.css("marginBottom")
7065 });
7066 this.originalElement.css({
7067 marginLeft: 0,
7068 marginTop: 0,
7069 marginRight: 0,
7070 marginBottom: 0
7071 });
7072 // support: Safari
7073 // Prevent Safari textarea resize
7074 this.originalResizeStyle = this.originalElement.css("resize");
7075 this.originalElement.css("resize", "none");
7076
7077 this._proportionallyResizeElements.push( this.originalElement.css({
7078 position: "static",
7079 zoom: 1,
7080 display: "block"
7081 }) );
7082
7083 // support: IE9
7084 // avoid IE jump (hard set the margin)
7085 this.originalElement.css({ margin: this.originalElement.css("margin") });
7086
7087 this._proportionallyResize();
7088 }
7089
7090 this.handles = o.handles ||
7091 ( !$(".ui-resizable-handle", this.element).length ?
7092 "e,s,se" : {
7093 n: ".ui-resizable-n",
7094 e: ".ui-resizable-e",
7095 s: ".ui-resizable-s",
7096 w: ".ui-resizable-w",
7097 se: ".ui-resizable-se",
7098 sw: ".ui-resizable-sw",
7099 ne: ".ui-resizable-ne",
7100 nw: ".ui-resizable-nw"
7101 } );
7102
7103 this._handles = $();
7104 if ( this.handles.constructor === String ) {
7105
7106 if ( this.handles === "all") {
7107 this.handles = "n,e,s,w,se,sw,ne,nw";
7108 }
7109
7110 n = this.handles.split(",");
7111 this.handles = {};
7112
7113 for (i = 0; i < n.length; i++) {
7114
7115 handle = $.trim(n[i]);
7116 hname = "ui-resizable-" + handle;
7117 axis = $("<div class='ui-resizable-handle " + hname + "'></div>");
7118
7119 axis.css({ zIndex: o.zIndex });
7120
7121 // TODO : What's going on here?
7122 if ("se" === handle) {
7123 axis.addClass("ui-icon ui-icon-gripsmall-diagonal-se");
7124 }
7125
7126 this.handles[handle] = ".ui-resizable-" + handle;
7127 this.element.append(axis);
7128 }
7129
7130 }
7131
7132 this._renderAxis = function(target) {
7133
7134 var i, axis, padPos, padWrapper;
7135
7136 target = target || this.element;
7137
7138 for (i in this.handles) {
7139
7140 if (this.handles[i].constructor === String) {
7141 this.handles[i] = this.element.children( this.handles[ i ] ).first().show();
7142 } else if ( this.handles[ i ].jquery || this.handles[ i ].nodeType ) {
7143 this.handles[ i ] = $( this.handles[ i ] );
7144 this._on( this.handles[ i ], { "mousedown": that._mouseDown });
7145 }
7146
7147 if (this.elementIsWrapper && this.originalElement[0].nodeName.match(/^(textarea|input|select|button)$/i)) {
7148
7149 axis = $(this.handles[i], this.element);
7150
7151 padWrapper = /sw|ne|nw|se|n|s/.test(i) ? axis.outerHeight() : axis.outerWidth();
7152
7153 padPos = [ "padding",
7154 /ne|nw|n/.test(i) ? "Top" :
7155 /se|sw|s/.test(i) ? "Bottom" :
7156 /^e$/.test(i) ? "Right" : "Left" ].join("");
7157
7158 target.css(padPos, padWrapper);
7159
7160 this._proportionallyResize();
7161 }
7162
7163 this._handles = this._handles.add( this.handles[ i ] );
7164 }
7165 };
7166
7167 // TODO: make renderAxis a prototype function
7168 this._renderAxis(this.element);
7169
7170 this._handles = this._handles.add( this.element.find( ".ui-resizable-handle" ) );
7171 this._handles.disableSelection();
7172
7173 this._handles.mouseover(function() {
7174 if (!that.resizing) {
7175 if (this.className) {
7176 axis = this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i);
7177 }
7178 that.axis = axis && axis[1] ? axis[1] : "se";
7179 }
7180 });
7181
7182 if (o.autoHide) {
7183 this._handles.hide();
7184 $(this.element)
7185 .addClass("ui-resizable-autohide")
7186 .mouseenter(function() {
7187 if (o.disabled) {
7188 return;
7189 }
7190 $(this).removeClass("ui-resizable-autohide");
7191 that._handles.show();
7192 })
7193 .mouseleave(function() {
7194 if (o.disabled) {
7195 return;
7196 }
7197 if (!that.resizing) {
7198 $(this).addClass("ui-resizable-autohide");
7199 that._handles.hide();
7200 }
7201 });
7202 }
7203
7204 this._mouseInit();
7205 },
7206
7207 _destroy: function() {
7208
7209 this._mouseDestroy();
7210
7211 var wrapper,
7212 _destroy = function(exp) {
7213 $(exp)
7214 .removeClass("ui-resizable ui-resizable-disabled ui-resizable-resizing")
7215 .removeData("resizable")
7216 .removeData("ui-resizable")
7217 .unbind(".resizable")
7218 .find(".ui-resizable-handle")
7219 .remove();
7220 };
7221
7222 // TODO: Unwrap at same DOM position
7223 if (this.elementIsWrapper) {
7224 _destroy(this.element);
7225 wrapper = this.element;
7226 this.originalElement.css({
7227 position: wrapper.css("position"),
7228 width: wrapper.outerWidth(),
7229 height: wrapper.outerHeight(),
7230 top: wrapper.css("top"),
7231 left: wrapper.css("left")
7232 }).insertAfter( wrapper );
7233 wrapper.remove();
7234 }
7235
7236 this.originalElement.css("resize", this.originalResizeStyle);
7237 _destroy(this.originalElement);
7238
7239 return this;
7240 },
7241
7242 _mouseCapture: function(event) {
7243 var i, handle,
7244 capture = false;
7245
7246 for (i in this.handles) {
7247 handle = $(this.handles[i])[0];
7248 if (handle === event.target || $.contains(handle, event.target)) {
7249 capture = true;
7250 }
7251 }
7252
7253 return !this.options.disabled && capture;
7254 },
7255
7256 _mouseStart: function(event) {
7257
7258 var curleft, curtop, cursor,
7259 o = this.options,
7260 el = this.element;
7261
7262 this.resizing = true;
7263
7264 this._renderProxy();
7265
7266 curleft = this._num(this.helper.css("left"));
7267 curtop = this._num(this.helper.css("top"));
7268
7269 if (o.containment) {
7270 curleft += $(o.containment).scrollLeft() || 0;
7271 curtop += $(o.containment).scrollTop() || 0;
7272 }
7273
7274 this.offset = this.helper.offset();
7275 this.position = { left: curleft, top: curtop };
7276
7277 this.size = this._helper ? {
7278 width: this.helper.width(),
7279 height: this.helper.height()
7280 } : {
7281 width: el.width(),
7282 height: el.height()
7283 };
7284
7285 this.originalSize = this._helper ? {
7286 width: el.outerWidth(),
7287 height: el.outerHeight()
7288 } : {
7289 width: el.width(),
7290 height: el.height()
7291 };
7292
7293 this.sizeDiff = {
7294 width: el.outerWidth() - el.width(),
7295 height: el.outerHeight() - el.height()
7296 };
7297
7298 this.originalPosition = { left: curleft, top: curtop };
7299 this.originalMousePosition = { left: event.pageX, top: event.pageY };
7300
7301 this.aspectRatio = (typeof o.aspectRatio === "number") ?
7302 o.aspectRatio :
7303 ((this.originalSize.width / this.originalSize.height) || 1);
7304
7305 cursor = $(".ui-resizable-" + this.axis).css("cursor");
7306 $("body").css("cursor", cursor === "auto" ? this.axis + "-resize" : cursor);
7307
7308 el.addClass("ui-resizable-resizing");
7309 this._propagate("start", event);
7310 return true;
7311 },
7312
7313 _mouseDrag: function(event) {
7314
7315 var data, props,
7316 smp = this.originalMousePosition,
7317 a = this.axis,
7318 dx = (event.pageX - smp.left) || 0,
7319 dy = (event.pageY - smp.top) || 0,
7320 trigger = this._change[a];
7321
7322 this._updatePrevProperties();
7323
7324 if (!trigger) {
7325 return false;
7326 }
7327
7328 data = trigger.apply(this, [ event, dx, dy ]);
7329
7330 this._updateVirtualBoundaries(event.shiftKey);
7331 if (this._aspectRatio || event.shiftKey) {
7332 data = this._updateRatio(data, event);
7333 }
7334
7335 data = this._respectSize(data, event);
7336
7337 this._updateCache(data);
7338
7339 this._propagate("resize", event);
7340
7341 props = this._applyChanges();
7342
7343 if ( !this._helper && this._proportionallyResizeElements.length ) {
7344 this._proportionallyResize();
7345 }
7346
7347 if ( !$.isEmptyObject( props ) ) {
7348 this._updatePrevProperties();
7349 this._trigger( "resize", event, this.ui() );
7350 this._applyChanges();
7351 }
7352
7353 return false;
7354 },
7355
7356 _mouseStop: function(event) {
7357
7358 this.resizing = false;
7359 var pr, ista, soffseth, soffsetw, s, left, top,
7360 o = this.options, that = this;
7361
7362 if (this._helper) {
7363
7364 pr = this._proportionallyResizeElements;
7365 ista = pr.length && (/textarea/i).test(pr[0].nodeName);
7366 soffseth = ista && this._hasScroll(pr[0], "left") ? 0 : that.sizeDiff.height;
7367 soffsetw = ista ? 0 : that.sizeDiff.width;
7368
7369 s = {
7370 width: (that.helper.width() - soffsetw),
7371 height: (that.helper.height() - soffseth)
7372 };
7373 left = (parseInt(that.element.css("left"), 10) +
7374 (that.position.left - that.originalPosition.left)) || null;
7375 top = (parseInt(that.element.css("top"), 10) +
7376 (that.position.top - that.originalPosition.top)) || null;
7377
7378 if (!o.animate) {
7379 this.element.css($.extend(s, { top: top, left: left }));
7380 }
7381
7382 that.helper.height(that.size.height);
7383 that.helper.width(that.size.width);
7384
7385 if (this._helper && !o.animate) {
7386 this._proportionallyResize();
7387 }
7388 }
7389
7390 $("body").css("cursor", "auto");
7391
7392 this.element.removeClass("ui-resizable-resizing");
7393
7394 this._propagate("stop", event);
7395
7396 if (this._helper) {
7397 this.helper.remove();
7398 }
7399
7400 return false;
7401
7402 },
7403
7404 _updatePrevProperties: function() {
7405 this.prevPosition = {
7406 top: this.position.top,
7407 left: this.position.left
7408 };
7409 this.prevSize = {
7410 width: this.size.width,
7411 height: this.size.height
7412 };
7413 },
7414
7415 _applyChanges: function() {
7416 var props = {};
7417
7418 if ( this.position.top !== this.prevPosition.top ) {
7419 props.top = this.position.top + "px";
7420 }
7421 if ( this.position.left !== this.prevPosition.left ) {
7422 props.left = this.position.left + "px";
7423 }
7424 if ( this.size.width !== this.prevSize.width ) {
7425 props.width = this.size.width + "px";
7426 }
7427 if ( this.size.height !== this.prevSize.height ) {
7428 props.height = this.size.height + "px";
7429 }
7430
7431 this.helper.css( props );
7432
7433 return props;
7434 },
7435
7436 _updateVirtualBoundaries: function(forceAspectRatio) {
7437 var pMinWidth, pMaxWidth, pMinHeight, pMaxHeight, b,
7438 o = this.options;
7439
7440 b = {
7441 minWidth: this._isNumber(o.minWidth) ? o.minWidth : 0,
7442 maxWidth: this._isNumber(o.maxWidth) ? o.maxWidth : Infinity,
7443 minHeight: this._isNumber(o.minHeight) ? o.minHeight : 0,
7444 maxHeight: this._isNumber(o.maxHeight) ? o.maxHeight : Infinity
7445 };
7446
7447 if (this._aspectRatio || forceAspectRatio) {
7448 pMinWidth = b.minHeight * this.aspectRatio;
7449 pMinHeight = b.minWidth / this.aspectRatio;
7450 pMaxWidth = b.maxHeight * this.aspectRatio;
7451 pMaxHeight = b.maxWidth / this.aspectRatio;
7452
7453 if (pMinWidth > b.minWidth) {
7454 b.minWidth = pMinWidth;
7455 }
7456 if (pMinHeight > b.minHeight) {
7457 b.minHeight = pMinHeight;
7458 }
7459 if (pMaxWidth < b.maxWidth) {
7460 b.maxWidth = pMaxWidth;
7461 }
7462 if (pMaxHeight < b.maxHeight) {
7463 b.maxHeight = pMaxHeight;
7464 }
7465 }
7466 this._vBoundaries = b;
7467 },
7468
7469 _updateCache: function(data) {
7470 this.offset = this.helper.offset();
7471 if (this._isNumber(data.left)) {
7472 this.position.left = data.left;
7473 }
7474 if (this._isNumber(data.top)) {
7475 this.position.top = data.top;
7476 }
7477 if (this._isNumber(data.height)) {
7478 this.size.height = data.height;
7479 }
7480 if (this._isNumber(data.width)) {
7481 this.size.width = data.width;
7482 }
7483 },
7484
7485 _updateRatio: function( data ) {
7486
7487 var cpos = this.position,
7488 csize = this.size,
7489 a = this.axis;
7490
7491 if (this._isNumber(data.height)) {
7492 data.width = (data.height * this.aspectRatio);
7493 } else if (this._isNumber(data.width)) {
7494 data.height = (data.width / this.aspectRatio);
7495 }
7496
7497 if (a === "sw") {
7498 data.left = cpos.left + (csize.width - data.width);
7499 data.top = null;
7500 }
7501 if (a === "nw") {
7502 data.top = cpos.top + (csize.height - data.height);
7503 data.left = cpos.left + (csize.width - data.width);
7504 }
7505
7506 return data;
7507 },
7508
7509 _respectSize: function( data ) {
7510
7511 var o = this._vBoundaries,
7512 a = this.axis,
7513 ismaxw = this._isNumber(data.width) && o.maxWidth && (o.maxWidth < data.width),
7514 ismaxh = this._isNumber(data.height) && o.maxHeight && (o.maxHeight < data.height),
7515 isminw = this._isNumber(data.width) && o.minWidth && (o.minWidth > data.width),
7516 isminh = this._isNumber(data.height) && o.minHeight && (o.minHeight > data.height),
7517 dw = this.originalPosition.left + this.originalSize.width,
7518 dh = this.position.top + this.size.height,
7519 cw = /sw|nw|w/.test(a), ch = /nw|ne|n/.test(a);
7520 if (isminw) {
7521 data.width = o.minWidth;
7522 }
7523 if (isminh) {
7524 data.height = o.minHeight;
7525 }
7526 if (ismaxw) {
7527 data.width = o.maxWidth;
7528 }
7529 if (ismaxh) {
7530 data.height = o.maxHeight;
7531 }
7532
7533 if (isminw && cw) {
7534 data.left = dw - o.minWidth;
7535 }
7536 if (ismaxw && cw) {
7537 data.left = dw - o.maxWidth;
7538 }
7539 if (isminh && ch) {
7540 data.top = dh - o.minHeight;
7541 }
7542 if (ismaxh && ch) {
7543 data.top = dh - o.maxHeight;
7544 }
7545
7546 // Fixing jump error on top/left - bug #2330
7547 if (!data.width && !data.height && !data.left && data.top) {
7548 data.top = null;
7549 } else if (!data.width && !data.height && !data.top && data.left) {
7550 data.left = null;
7551 }
7552
7553 return data;
7554 },
7555
7556 _getPaddingPlusBorderDimensions: function( element ) {
7557 var i = 0,
7558 widths = [],
7559 borders = [
7560 element.css( "borderTopWidth" ),
7561 element.css( "borderRightWidth" ),
7562 element.css( "borderBottomWidth" ),
7563 element.css( "borderLeftWidth" )
7564 ],
7565 paddings = [
7566 element.css( "paddingTop" ),
7567 element.css( "paddingRight" ),
7568 element.css( "paddingBottom" ),
7569 element.css( "paddingLeft" )
7570 ];
7571
7572 for ( ; i < 4; i++ ) {
7573 widths[ i ] = ( parseInt( borders[ i ], 10 ) || 0 );
7574 widths[ i ] += ( parseInt( paddings[ i ], 10 ) || 0 );
7575 }
7576
7577 return {
7578 height: widths[ 0 ] + widths[ 2 ],
7579 width: widths[ 1 ] + widths[ 3 ]
7580 };
7581 },
7582
7583 _proportionallyResize: function() {
7584
7585 if (!this._proportionallyResizeElements.length) {
7586 return;
7587 }
7588
7589 var prel,
7590 i = 0,
7591 element = this.helper || this.element;
7592
7593 for ( ; i < this._proportionallyResizeElements.length; i++) {
7594
7595 prel = this._proportionallyResizeElements[i];
7596
7597 // TODO: Seems like a bug to cache this.outerDimensions
7598 // considering that we are in a loop.
7599 if (!this.outerDimensions) {
7600 this.outerDimensions = this._getPaddingPlusBorderDimensions( prel );
7601 }
7602
7603 prel.css({
7604 height: (element.height() - this.outerDimensions.height) || 0,
7605 width: (element.width() - this.outerDimensions.width) || 0
7606 });
7607
7608 }
7609
7610 },
7611
7612 _renderProxy: function() {
7613
7614 var el = this.element, o = this.options;
7615 this.elementOffset = el.offset();
7616
7617 if (this._helper) {
7618
7619 this.helper = this.helper || $("<div style='overflow:hidden;'></div>");
7620
7621 this.helper.addClass(this._helper).css({
7622 width: this.element.outerWidth() - 1,
7623 height: this.element.outerHeight() - 1,
7624 position: "absolute",
7625 left: this.elementOffset.left + "px",
7626 top: this.elementOffset.top + "px",
7627 zIndex: ++o.zIndex //TODO: Don't modify option
7628 });
7629
7630 this.helper
7631 .appendTo("body")
7632 .disableSelection();
7633
7634 } else {
7635 this.helper = this.element;
7636 }
7637
7638 },
7639
7640 _change: {
7641 e: function(event, dx) {
7642 return { width: this.originalSize.width + dx };
7643 },
7644 w: function(event, dx) {
7645 var cs = this.originalSize, sp = this.originalPosition;
7646 return { left: sp.left + dx, width: cs.width - dx };
7647 },
7648 n: function(event, dx, dy) {
7649 var cs = this.originalSize, sp = this.originalPosition;
7650 return { top: sp.top + dy, height: cs.height - dy };
7651 },
7652 s: function(event, dx, dy) {
7653 return { height: this.originalSize.height + dy };
7654 },
7655 se: function(event, dx, dy) {
7656 return $.extend(this._change.s.apply(this, arguments),
7657 this._change.e.apply(this, [ event, dx, dy ]));
7658 },
7659 sw: function(event, dx, dy) {
7660 return $.extend(this._change.s.apply(this, arguments),
7661 this._change.w.apply(this, [ event, dx, dy ]));
7662 },
7663 ne: function(event, dx, dy) {
7664 return $.extend(this._change.n.apply(this, arguments),
7665 this._change.e.apply(this, [ event, dx, dy ]));
7666 },
7667 nw: function(event, dx, dy) {
7668 return $.extend(this._change.n.apply(this, arguments),
7669 this._change.w.apply(this, [ event, dx, dy ]));
7670 }
7671 },
7672
7673 _propagate: function(n, event) {
7674 $.ui.plugin.call(this, n, [ event, this.ui() ]);
7675 (n !== "resize" && this._trigger(n, event, this.ui()));
7676 },
7677
7678 plugins: {},
7679
7680 ui: function() {
7681 return {
7682 originalElement: this.originalElement,
7683 element: this.element,
7684 helper: this.helper,
7685 position: this.position,
7686 size: this.size,
7687 originalSize: this.originalSize,
7688 originalPosition: this.originalPosition
7689 };
7690 }
7691
7692 });
7693
7694 /*
7695 * Resizable Extensions
7696 */
7697
7698 $.ui.plugin.add("resizable", "animate", {
7699
7700 stop: function( event ) {
7701 var that = $(this).resizable( "instance" ),
7702 o = that.options,
7703 pr = that._proportionallyResizeElements,
7704 ista = pr.length && (/textarea/i).test(pr[0].nodeName),
7705 soffseth = ista && that._hasScroll(pr[0], "left") ? 0 : that.sizeDiff.height,
7706 soffsetw = ista ? 0 : that.sizeDiff.width,
7707 style = { width: (that.size.width - soffsetw), height: (that.size.height - soffseth) },
7708 left = (parseInt(that.element.css("left"), 10) +
7709 (that.position.left - that.originalPosition.left)) || null,
7710 top = (parseInt(that.element.css("top"), 10) +
7711 (that.position.top - that.originalPosition.top)) || null;
7712
7713 that.element.animate(
7714 $.extend(style, top && left ? { top: top, left: left } : {}), {
7715 duration: o.animateDuration,
7716 easing: o.animateEasing,
7717 step: function() {
7718
7719 var data = {
7720 width: parseInt(that.element.css("width"), 10),
7721 height: parseInt(that.element.css("height"), 10),
7722 top: parseInt(that.element.css("top"), 10),
7723 left: parseInt(that.element.css("left"), 10)
7724 };
7725
7726 if (pr && pr.length) {
7727 $(pr[0]).css({ width: data.width, height: data.height });
7728 }
7729
7730 // propagating resize, and updating values for each animation step
7731 that._updateCache(data);
7732 that._propagate("resize", event);
7733
7734 }
7735 }
7736 );
7737 }
7738
7739 });
7740
7741 $.ui.plugin.add( "resizable", "containment", {
7742
7743 start: function() {
7744 var element, p, co, ch, cw, width, height,
7745 that = $( this ).resizable( "instance" ),
7746 o = that.options,
7747 el = that.element,
7748 oc = o.containment,
7749 ce = ( oc instanceof $ ) ? oc.get( 0 ) : ( /parent/.test( oc ) ) ? el.parent().get( 0 ) : oc;
7750
7751 if ( !ce ) {
7752 return;
7753 }
7754
7755 that.containerElement = $( ce );
7756
7757 if ( /document/.test( oc ) || oc === document ) {
7758 that.containerOffset = {
7759 left: 0,
7760 top: 0
7761 };
7762 that.containerPosition = {
7763 left: 0,
7764 top: 0
7765 };
7766
7767 that.parentData = {
7768 element: $( document ),
7769 left: 0,
7770 top: 0,
7771 width: $( document ).width(),
7772 height: $( document ).height() || document.body.parentNode.scrollHeight
7773 };
7774 } else {
7775 element = $( ce );
7776 p = [];
7777 $([ "Top", "Right", "Left", "Bottom" ]).each(function( i, name ) {
7778 p[ i ] = that._num( element.css( "padding" + name ) );
7779 });
7780
7781 that.containerOffset = element.offset();
7782 that.containerPosition = element.position();
7783 that.containerSize = {
7784 height: ( element.innerHeight() - p[ 3 ] ),
7785 width: ( element.innerWidth() - p[ 1 ] )
7786 };
7787
7788 co = that.containerOffset;
7789 ch = that.containerSize.height;
7790 cw = that.containerSize.width;
7791 width = ( that._hasScroll ( ce, "left" ) ? ce.scrollWidth : cw );
7792 height = ( that._hasScroll ( ce ) ? ce.scrollHeight : ch ) ;
7793
7794 that.parentData = {
7795 element: ce,
7796 left: co.left,
7797 top: co.top,
7798 width: width,
7799 height: height
7800 };
7801 }
7802 },
7803
7804 resize: function( event ) {
7805 var woset, hoset, isParent, isOffsetRelative,
7806 that = $( this ).resizable( "instance" ),
7807 o = that.options,
7808 co = that.containerOffset,
7809 cp = that.position,
7810 pRatio = that._aspectRatio || event.shiftKey,
7811 cop = {
7812 top: 0,
7813 left: 0
7814 },
7815 ce = that.containerElement,
7816 continueResize = true;
7817
7818 if ( ce[ 0 ] !== document && ( /static/ ).test( ce.css( "position" ) ) ) {
7819 cop = co;
7820 }
7821
7822 if ( cp.left < ( that._helper ? co.left : 0 ) ) {
7823 that.size.width = that.size.width +
7824 ( that._helper ?
7825 ( that.position.left - co.left ) :
7826 ( that.position.left - cop.left ) );
7827
7828 if ( pRatio ) {
7829 that.size.height = that.size.width / that.aspectRatio;
7830 continueResize = false;
7831 }
7832 that.position.left = o.helper ? co.left : 0;
7833 }
7834
7835 if ( cp.top < ( that._helper ? co.top : 0 ) ) {
7836 that.size.height = that.size.height +
7837 ( that._helper ?
7838 ( that.position.top - co.top ) :
7839 that.position.top );
7840
7841 if ( pRatio ) {
7842 that.size.width = that.size.height * that.aspectRatio;
7843 continueResize = false;
7844 }
7845 that.position.top = that._helper ? co.top : 0;
7846 }
7847
7848 isParent = that.containerElement.get( 0 ) === that.element.parent().get( 0 );
7849 isOffsetRelative = /relative|absolute/.test( that.containerElement.css( "position" ) );
7850
7851 if ( isParent && isOffsetRelative ) {
7852 that.offset.left = that.parentData.left + that.position.left;
7853 that.offset.top = that.parentData.top + that.position.top;
7854 } else {
7855 that.offset.left = that.element.offset().left;
7856 that.offset.top = that.element.offset().top;
7857 }
7858
7859 woset = Math.abs( that.sizeDiff.width +
7860 (that._helper ?
7861 that.offset.left - cop.left :
7862 (that.offset.left - co.left)) );
7863
7864 hoset = Math.abs( that.sizeDiff.height +
7865 (that._helper ?
7866 that.offset.top - cop.top :
7867 (that.offset.top - co.top)) );
7868
7869 if ( woset + that.size.width >= that.parentData.width ) {
7870 that.size.width = that.parentData.width - woset;
7871 if ( pRatio ) {
7872 that.size.height = that.size.width / that.aspectRatio;
7873 continueResize = false;
7874 }
7875 }
7876
7877 if ( hoset + that.size.height >= that.parentData.height ) {
7878 that.size.height = that.parentData.height - hoset;
7879 if ( pRatio ) {
7880 that.size.width = that.size.height * that.aspectRatio;
7881 continueResize = false;
7882 }
7883 }
7884
7885 if ( !continueResize ) {
7886 that.position.left = that.prevPosition.left;
7887 that.position.top = that.prevPosition.top;
7888 that.size.width = that.prevSize.width;
7889 that.size.height = that.prevSize.height;
7890 }
7891 },
7892
7893 stop: function() {
7894 var that = $( this ).resizable( "instance" ),
7895 o = that.options,
7896 co = that.containerOffset,
7897 cop = that.containerPosition,
7898 ce = that.containerElement,
7899 helper = $( that.helper ),
7900 ho = helper.offset(),
7901 w = helper.outerWidth() - that.sizeDiff.width,
7902 h = helper.outerHeight() - that.sizeDiff.height;
7903
7904 if ( that._helper && !o.animate && ( /relative/ ).test( ce.css( "position" ) ) ) {
7905 $( this ).css({
7906 left: ho.left - cop.left - co.left,
7907 width: w,
7908 height: h
7909 });
7910 }
7911
7912 if ( that._helper && !o.animate && ( /static/ ).test( ce.css( "position" ) ) ) {
7913 $( this ).css({
7914 left: ho.left - cop.left - co.left,
7915 width: w,
7916 height: h
7917 });
7918 }
7919 }
7920 });
7921
7922 $.ui.plugin.add("resizable", "alsoResize", {
7923
7924 start: function() {
7925 var that = $(this).resizable( "instance" ),
7926 o = that.options;
7927
7928 $(o.alsoResize).each(function() {
7929 var el = $(this);
7930 el.data("ui-resizable-alsoresize", {
7931 width: parseInt(el.width(), 10), height: parseInt(el.height(), 10),
7932 left: parseInt(el.css("left"), 10), top: parseInt(el.css("top"), 10)
7933 });
7934 });
7935 },
7936
7937 resize: function(event, ui) {
7938 var that = $(this).resizable( "instance" ),
7939 o = that.options,
7940 os = that.originalSize,
7941 op = that.originalPosition,
7942 delta = {
7943 height: (that.size.height - os.height) || 0,
7944 width: (that.size.width - os.width) || 0,
7945 top: (that.position.top - op.top) || 0,
7946 left: (that.position.left - op.left) || 0
7947 };
7948
7949 $(o.alsoResize).each(function() {
7950 var el = $(this), start = $(this).data("ui-resizable-alsoresize"), style = {},
7951 css = el.parents(ui.originalElement[0]).length ?
7952 [ "width", "height" ] :
7953 [ "width", "height", "top", "left" ];
7954
7955 $.each(css, function(i, prop) {
7956 var sum = (start[prop] || 0) + (delta[prop] || 0);
7957 if (sum && sum >= 0) {
7958 style[prop] = sum || null;
7959 }
7960 });
7961
7962 el.css(style);
7963 });
7964 },
7965
7966 stop: function() {
7967 $(this).removeData("resizable-alsoresize");
7968 }
7969 });
7970
7971 $.ui.plugin.add("resizable", "ghost", {
7972
7973 start: function() {
7974
7975 var that = $(this).resizable( "instance" ), o = that.options, cs = that.size;
7976
7977 that.ghost = that.originalElement.clone();
7978 that.ghost
7979 .css({
7980 opacity: 0.25,
7981 display: "block",
7982 position: "relative",
7983 height: cs.height,
7984 width: cs.width,
7985 margin: 0,
7986 left: 0,
7987 top: 0
7988 })
7989 .addClass("ui-resizable-ghost")
7990 .addClass(typeof o.ghost === "string" ? o.ghost : "");
7991
7992 that.ghost.appendTo(that.helper);
7993
7994 },
7995
7996 resize: function() {
7997 var that = $(this).resizable( "instance" );
7998 if (that.ghost) {
7999 that.ghost.css({
8000 position: "relative",
8001 height: that.size.height,
8002 width: that.size.width
8003 });
8004 }
8005 },
8006
8007 stop: function() {
8008 var that = $(this).resizable( "instance" );
8009 if (that.ghost && that.helper) {
8010 that.helper.get(0).removeChild(that.ghost.get(0));
8011 }
8012 }
8013
8014 });
8015
8016 $.ui.plugin.add("resizable", "grid", {
8017
8018 resize: function() {
8019 var outerDimensions,
8020 that = $(this).resizable( "instance" ),
8021 o = that.options,
8022 cs = that.size,
8023 os = that.originalSize,
8024 op = that.originalPosition,
8025 a = that.axis,
8026 grid = typeof o.grid === "number" ? [ o.grid, o.grid ] : o.grid,
8027 gridX = (grid[0] || 1),
8028 gridY = (grid[1] || 1),
8029 ox = Math.round((cs.width - os.width) / gridX) * gridX,
8030 oy = Math.round((cs.height - os.height) / gridY) * gridY,
8031 newWidth = os.width + ox,
8032 newHeight = os.height + oy,
8033 isMaxWidth = o.maxWidth && (o.maxWidth < newWidth),
8034 isMaxHeight = o.maxHeight && (o.maxHeight < newHeight),
8035 isMinWidth = o.minWidth && (o.minWidth > newWidth),
8036 isMinHeight = o.minHeight && (o.minHeight > newHeight);
8037
8038 o.grid = grid;
8039
8040 if (isMinWidth) {
8041 newWidth += gridX;
8042 }
8043 if (isMinHeight) {
8044 newHeight += gridY;
8045 }
8046 if (isMaxWidth) {
8047 newWidth -= gridX;
8048 }
8049 if (isMaxHeight) {
8050 newHeight -= gridY;
8051 }
8052
8053 if (/^(se|s|e)$/.test(a)) {
8054 that.size.width = newWidth;
8055 that.size.height = newHeight;
8056 } else if (/^(ne)$/.test(a)) {
8057 that.size.width = newWidth;
8058 that.size.height = newHeight;
8059 that.position.top = op.top - oy;
8060 } else if (/^(sw)$/.test(a)) {
8061 that.size.width = newWidth;
8062 that.size.height = newHeight;
8063 that.position.left = op.left - ox;
8064 } else {
8065 if ( newHeight - gridY <= 0 || newWidth - gridX <= 0) {
8066 outerDimensions = that._getPaddingPlusBorderDimensions( this );
8067 }
8068
8069 if ( newHeight - gridY > 0 ) {
8070 that.size.height = newHeight;
8071 that.position.top = op.top - oy;
8072 } else {
8073 newHeight = gridY - outerDimensions.height;
8074 that.size.height = newHeight;
8075 that.position.top = op.top + os.height - newHeight;
8076 }
8077 if ( newWidth - gridX > 0 ) {
8078 that.size.width = newWidth;
8079 that.position.left = op.left - ox;
8080 } else {
8081 newWidth = gridX - outerDimensions.width;
8082 that.size.width = newWidth;
8083 that.position.left = op.left + os.width - newWidth;
8084 }
8085 }
8086 }
8087
8088 });
8089
8090 var resizable = $.ui.resizable;
8091
8092
8093 /*!
8094 * jQuery UI Dialog 1.11.4
8095 * http://jqueryui.com
8096 *
8097 * Copyright jQuery Foundation and other contributors
8098 * Released under the MIT license.
8099 * http://jquery.org/license
8100 *
8101 * http://api.jqueryui.com/dialog/
8102 */
8103
8104
8105 var dialog = $.widget( "ui.dialog", {
8106 version: "1.11.4",
8107 options: {
8108 appendTo: "body",
8109 autoOpen: true,
8110 buttons: [],
8111 closeOnEscape: true,
8112 closeText: "Close",
8113 dialogClass: "",
8114 draggable: true,
8115 hide: null,
8116 height: "auto",
8117 maxHeight: null,
8118 maxWidth: null,
8119 minHeight: 150,
8120 minWidth: 150,
8121 modal: false,
8122 position: {
8123 my: "center",
8124 at: "center",
8125 of: window,
8126 collision: "fit",
8127 // Ensure the titlebar is always visible
8128 using: function( pos ) {
8129 var topOffset = $( this ).css( pos ).offset().top;
8130 if ( topOffset < 0 ) {
8131 $( this ).css( "top", pos.top - topOffset );
8132 }
8133 }
8134 },
8135 resizable: true,
8136 show: null,
8137 title: null,
8138 width: 300,
8139
8140 // callbacks
8141 beforeClose: null,
8142 close: null,
8143 drag: null,
8144 dragStart: null,
8145 dragStop: null,
8146 focus: null,
8147 open: null,
8148 resize: null,
8149 resizeStart: null,
8150 resizeStop: null
8151 },
8152
8153 sizeRelatedOptions: {
8154 buttons: true,
8155 height: true,
8156 maxHeight: true,
8157 maxWidth: true,
8158 minHeight: true,
8159 minWidth: true,
8160 width: true
8161 },
8162
8163 resizableRelatedOptions: {
8164 maxHeight: true,
8165 maxWidth: true,
8166 minHeight: true,
8167 minWidth: true
8168 },
8169
8170 _create: function() {
8171 this.originalCss = {
8172 display: this.element[ 0 ].style.display,
8173 width: this.element[ 0 ].style.width,
8174 minHeight: this.element[ 0 ].style.minHeight,
8175 maxHeight: this.element[ 0 ].style.maxHeight,
8176 height: this.element[ 0 ].style.height
8177 };
8178 this.originalPosition = {
8179 parent: this.element.parent(),
8180 index: this.element.parent().children().index( this.element )
8181 };
8182 this.originalTitle = this.element.attr( "title" );
8183 this.options.title = this.options.title || this.originalTitle;
8184
8185 this._createWrapper();
8186
8187 this.element
8188 .show()
8189 .removeAttr( "title" )
8190 .addClass( "ui-dialog-content ui-widget-content" )
8191 .appendTo( this.uiDialog );
8192
8193 this._createTitlebar();
8194 this._createButtonPane();
8195
8196 if ( this.options.draggable && $.fn.draggable ) {
8197 this._makeDraggable();
8198 }
8199 if ( this.options.resizable && $.fn.resizable ) {
8200 this._makeResizable();
8201 }
8202
8203 this._isOpen = false;
8204
8205 this._trackFocus();
8206 },
8207
8208 _init: function() {
8209 if ( this.options.autoOpen ) {
8210 this.open();
8211 }
8212 },
8213
8214 _appendTo: function() {
8215 var element = this.options.appendTo;
8216 if ( element && (element.jquery || element.nodeType) ) {
8217 return $( element );
8218 }
8219 return this.document.find( element || "body" ).eq( 0 );
8220 },
8221
8222 _destroy: function() {
8223 var next,
8224 originalPosition = this.originalPosition;
8225
8226 this._untrackInstance();
8227 this._destroyOverlay();
8228
8229 this.element
8230 .removeUniqueId()
8231 .removeClass( "ui-dialog-content ui-widget-content" )
8232 .css( this.originalCss )
8233 // Without detaching first, the following becomes really slow
8234 .detach();
8235
8236 this.uiDialog.stop( true, true ).remove();
8237
8238 if ( this.originalTitle ) {
8239 this.element.attr( "title", this.originalTitle );
8240 }
8241
8242 next = originalPosition.parent.children().eq( originalPosition.index );
8243 // Don't try to place the dialog next to itself (#8613)
8244 if ( next.length && next[ 0 ] !== this.element[ 0 ] ) {
8245 next.before( this.element );
8246 } else {
8247 originalPosition.parent.append( this.element );
8248 }
8249 },
8250
8251 widget: function() {
8252 return this.uiDialog;
8253 },
8254
8255 disable: $.noop,
8256 enable: $.noop,
8257
8258 close: function( event ) {
8259 var activeElement,
8260 that = this;
8261
8262 if ( !this._isOpen || this._trigger( "beforeClose", event ) === false ) {
8263 return;
8264 }
8265
8266 this._isOpen = false;
8267 this._focusedElement = null;
8268 this._destroyOverlay();
8269 this._untrackInstance();
8270
8271 if ( !this.opener.filter( ":focusable" ).focus().length ) {
8272
8273 // support: IE9
8274 // IE9 throws an "Unspecified error" accessing document.activeElement from an <iframe>
8275 try {
8276 activeElement = this.document[ 0 ].activeElement;
8277
8278 // Support: IE9, IE10
8279 // If the <body> is blurred, IE will switch windows, see #4520
8280 if ( activeElement && activeElement.nodeName.toLowerCase() !== "body" ) {
8281
8282 // Hiding a focused element doesn't trigger blur in WebKit
8283 // so in case we have nothing to focus on, explicitly blur the active element
8284 // https://bugs.webkit.org/show_bug.cgi?id=47182
8285 $( activeElement ).blur();
8286 }
8287 } catch ( error ) {}
8288 }
8289
8290 this._hide( this.uiDialog, this.options.hide, function() {
8291 that._trigger( "close", event );
8292 });
8293 },
8294
8295 isOpen: function() {
8296 return this._isOpen;
8297 },
8298
8299 moveToTop: function() {
8300 this._moveToTop();
8301 },
8302
8303 _moveToTop: function( event, silent ) {
8304 var moved = false,
8305 zIndices = this.uiDialog.siblings( ".ui-front:visible" ).map(function() {
8306 return +$( this ).css( "z-index" );
8307 }).get(),
8308 zIndexMax = Math.max.apply( null, zIndices );
8309
8310 if ( zIndexMax >= +this.uiDialog.css( "z-index" ) ) {
8311 this.uiDialog.css( "z-index", zIndexMax + 1 );
8312 moved = true;
8313 }
8314
8315 if ( moved && !silent ) {
8316 this._trigger( "focus", event );
8317 }
8318 return moved;
8319 },
8320
8321 open: function() {
8322 var that = this;
8323 if ( this._isOpen ) {
8324 if ( this._moveToTop() ) {
8325 this._focusTabbable();
8326 }
8327 return;
8328 }
8329
8330 this._isOpen = true;
8331 this.opener = $( this.document[ 0 ].activeElement );
8332
8333 this._size();
8334 this._position();
8335 this._createOverlay();
8336 this._moveToTop( null, true );
8337
8338 // Ensure the overlay is moved to the top with the dialog, but only when
8339 // opening. The overlay shouldn't move after the dialog is open so that
8340 // modeless dialogs opened after the modal dialog stack properly.
8341 if ( this.overlay ) {
8342 this.overlay.css( "z-index", this.uiDialog.css( "z-index" ) - 1 );
8343 }
8344
8345 this._show( this.uiDialog, this.options.show, function() {
8346 that._focusTabbable();
8347 that._trigger( "focus" );
8348 });
8349
8350 // Track the dialog immediately upon openening in case a focus event
8351 // somehow occurs outside of the dialog before an element inside the
8352 // dialog is focused (#10152)
8353 this._makeFocusTarget();
8354
8355 this._trigger( "open" );
8356 },
8357
8358 _focusTabbable: function() {
8359 // Set focus to the first match:
8360 // 1. An element that was focused previously
8361 // 2. First element inside the dialog matching [autofocus]
8362 // 3. Tabbable element inside the content element
8363 // 4. Tabbable element inside the buttonpane
8364 // 5. The close button
8365 // 6. The dialog itself
8366 var hasFocus = this._focusedElement;
8367 if ( !hasFocus ) {
8368 hasFocus = this.element.find( "[autofocus]" );
8369 }
8370 if ( !hasFocus.length ) {
8371 hasFocus = this.element.find( ":tabbable" );
8372 }
8373 if ( !hasFocus.length ) {
8374 hasFocus = this.uiDialogButtonPane.find( ":tabbable" );
8375 }
8376 if ( !hasFocus.length ) {
8377 hasFocus = this.uiDialogTitlebarClose.filter( ":tabbable" );
8378 }
8379 if ( !hasFocus.length ) {
8380 hasFocus = this.uiDialog;
8381 }
8382 hasFocus.eq( 0 ).focus();
8383 },
8384
8385 _keepFocus: function( event ) {
8386 function checkFocus() {
8387 var activeElement = this.document[0].activeElement,
8388 isActive = this.uiDialog[0] === activeElement ||
8389 $.contains( this.uiDialog[0], activeElement );
8390 if ( !isActive ) {
8391 this._focusTabbable();
8392 }
8393 }
8394 event.preventDefault();
8395 checkFocus.call( this );
8396 // support: IE
8397 // IE <= 8 doesn't prevent moving focus even with event.preventDefault()
8398 // so we check again later
8399 this._delay( checkFocus );
8400 },
8401
8402 _createWrapper: function() {
8403 this.uiDialog = $("<div>")
8404 .addClass( "ui-dialog ui-widget ui-widget-content ui-corner-all ui-front " +
8405 this.options.dialogClass )
8406 .hide()
8407 .attr({
8408 // Setting tabIndex makes the div focusable
8409 tabIndex: -1,
8410 role: "dialog"
8411 })
8412 .appendTo( this._appendTo() );
8413
8414 this._on( this.uiDialog, {
8415 keydown: function( event ) {
8416 if ( this.options.closeOnEscape && !event.isDefaultPrevented() && event.keyCode &&
8417 event.keyCode === $.ui.keyCode.ESCAPE ) {
8418 event.preventDefault();
8419 this.close( event );
8420 return;
8421 }
8422
8423 // prevent tabbing out of dialogs
8424 if ( event.keyCode !== $.ui.keyCode.TAB || event.isDefaultPrevented() ) {
8425 return;
8426 }
8427 var tabbables = this.uiDialog.find( ":tabbable" ),
8428 first = tabbables.filter( ":first" ),
8429 last = tabbables.filter( ":last" );
8430
8431 if ( ( event.target === last[0] || event.target === this.uiDialog[0] ) && !event.shiftKey ) {
8432 this._delay(function() {
8433 first.focus();
8434 });
8435 event.preventDefault();
8436 } else if ( ( event.target === first[0] || event.target === this.uiDialog[0] ) && event.shiftKey ) {
8437 this._delay(function() {
8438 last.focus();
8439 });
8440 event.preventDefault();
8441 }
8442 },
8443 mousedown: function( event ) {
8444 if ( this._moveToTop( event ) ) {
8445 this._focusTabbable();
8446 }
8447 }
8448 });
8449
8450 // We assume that any existing aria-describedby attribute means
8451 // that the dialog content is marked up properly
8452 // otherwise we brute force the content as the description
8453 if ( !this.element.find( "[aria-describedby]" ).length ) {
8454 this.uiDialog.attr({
8455 "aria-describedby": this.element.uniqueId().attr( "id" )
8456 });
8457 }
8458 },
8459
8460 _createTitlebar: function() {
8461 var uiDialogTitle;
8462
8463 this.uiDialogTitlebar = $( "<div>" )
8464 .addClass( "ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix" )
8465 .prependTo( this.uiDialog );
8466 this._on( this.uiDialogTitlebar, {
8467 mousedown: function( event ) {
8468 // Don't prevent click on close button (#8838)
8469 // Focusing a dialog that is partially scrolled out of view
8470 // causes the browser to scroll it into view, preventing the click event
8471 if ( !$( event.target ).closest( ".ui-dialog-titlebar-close" ) ) {
8472 // Dialog isn't getting focus when dragging (#8063)
8473 this.uiDialog.focus();
8474 }
8475 }
8476 });
8477
8478 // support: IE
8479 // Use type="button" to prevent enter keypresses in textboxes from closing the
8480 // dialog in IE (#9312)
8481 this.uiDialogTitlebarClose = $( "<button type='button'></button>" )
8482 .button({
8483 label: this.options.closeText,
8484 icons: {
8485 primary: "ui-icon-closethick"
8486 },
8487 text: false
8488 })
8489 .addClass( "ui-dialog-titlebar-close" )
8490 .appendTo( this.uiDialogTitlebar );
8491 this._on( this.uiDialogTitlebarClose, {
8492 click: function( event ) {
8493 event.preventDefault();
8494 this.close( event );
8495 }
8496 });
8497
8498 uiDialogTitle = $( "<span>" )
8499 .uniqueId()
8500 .addClass( "ui-dialog-title" )
8501 .prependTo( this.uiDialogTitlebar );
8502 this._title( uiDialogTitle );
8503
8504 this.uiDialog.attr({
8505 "aria-labelledby": uiDialogTitle.attr( "id" )
8506 });
8507 },
8508
8509 _title: function( title ) {
8510 if ( !this.options.title ) {
8511 title.html( " " );
8512 }
8513 title.text( this.options.title );
8514 },
8515
8516 _createButtonPane: function() {
8517 this.uiDialogButtonPane = $( "<div>" )
8518 .addClass( "ui-dialog-buttonpane ui-widget-content ui-helper-clearfix" );
8519
8520 this.uiButtonSet = $( "<div>" )
8521 .addClass( "ui-dialog-buttonset" )
8522 .appendTo( this.uiDialogButtonPane );
8523
8524 this._createButtons();
8525 },
8526
8527 _createButtons: function() {
8528 var that = this,
8529 buttons = this.options.buttons;
8530
8531 // if we already have a button pane, remove it
8532 this.uiDialogButtonPane.remove();
8533 this.uiButtonSet.empty();
8534
8535 if ( $.isEmptyObject( buttons ) || ($.isArray( buttons ) && !buttons.length) ) {
8536 this.uiDialog.removeClass( "ui-dialog-buttons" );
8537 return;
8538 }
8539
8540 $.each( buttons, function( name, props ) {
8541 var click, buttonOptions;
8542 props = $.isFunction( props ) ?
8543 { click: props, text: name } :
8544 props;
8545 // Default to a non-submitting button
8546 props = $.extend( { type: "button" }, props );
8547 // Change the context for the click callback to be the main element
8548 click = props.click;
8549 props.click = function() {
8550 click.apply( that.element[ 0 ], arguments );
8551 };
8552 buttonOptions = {
8553 icons: props.icons,
8554 text: props.showText
8555 };
8556 delete props.icons;
8557 delete props.showText;
8558 $( "<button></button>", props )
8559 .button( buttonOptions )
8560 .appendTo( that.uiButtonSet );
8561 });
8562 this.uiDialog.addClass( "ui-dialog-buttons" );
8563 this.uiDialogButtonPane.appendTo( this.uiDialog );
8564 },
8565
8566 _makeDraggable: function() {
8567 var that = this,
8568 options = this.options;
8569
8570 function filteredUi( ui ) {
8571 return {
8572 position: ui.position,
8573 offset: ui.offset
8574 };
8575 }
8576
8577 this.uiDialog.draggable({
8578 cancel: ".ui-dialog-content, .ui-dialog-titlebar-close",
8579 handle: ".ui-dialog-titlebar",
8580 containment: "document",
8581 start: function( event, ui ) {
8582 $( this ).addClass( "ui-dialog-dragging" );
8583 that._blockFrames();
8584 that._trigger( "dragStart", event, filteredUi( ui ) );
8585 },
8586 drag: function( event, ui ) {
8587 that._trigger( "drag", event, filteredUi( ui ) );
8588 },
8589 stop: function( event, ui ) {
8590 var left = ui.offset.left - that.document.scrollLeft(),
8591 top = ui.offset.top - that.document.scrollTop();
8592
8593 options.position = {
8594 my: "left top",
8595 at: "left" + (left >= 0 ? "+" : "") + left + " " +
8596 "top" + (top >= 0 ? "+" : "") + top,
8597 of: that.window
8598 };
8599 $( this ).removeClass( "ui-dialog-dragging" );
8600 that._unblockFrames();
8601 that._trigger( "dragStop", event, filteredUi( ui ) );
8602 }
8603 });
8604 },
8605
8606 _makeResizable: function() {
8607 var that = this,
8608 options = this.options,
8609 handles = options.resizable,
8610 // .ui-resizable has position: relative defined in the stylesheet
8611 // but dialogs have to use absolute or fixed positioning
8612 position = this.uiDialog.css("position"),
8613 resizeHandles = typeof handles === "string" ?
8614 handles :
8615 "n,e,s,w,se,sw,ne,nw";
8616
8617 function filteredUi( ui ) {
8618 return {
8619 originalPosition: ui.originalPosition,
8620 originalSize: ui.originalSize,
8621 position: ui.position,
8622 size: ui.size
8623 };
8624 }
8625
8626 this.uiDialog.resizable({
8627 cancel: ".ui-dialog-content",
8628 containment: "document",
8629 alsoResize: this.element,
8630 maxWidth: options.maxWidth,
8631 maxHeight: options.maxHeight,
8632 minWidth: options.minWidth,
8633 minHeight: this._minHeight(),
8634 handles: resizeHandles,
8635 start: function( event, ui ) {
8636 $( this ).addClass( "ui-dialog-resizing" );
8637 that._blockFrames();
8638 that._trigger( "resizeStart", event, filteredUi( ui ) );
8639 },
8640 resize: function( event, ui ) {
8641 that._trigger( "resize", event, filteredUi( ui ) );
8642 },
8643 stop: function( event, ui ) {
8644 var offset = that.uiDialog.offset(),
8645 left = offset.left - that.document.scrollLeft(),
8646 top = offset.top - that.document.scrollTop();
8647
8648 options.height = that.uiDialog.height();
8649 options.width = that.uiDialog.width();
8650 options.position = {
8651 my: "left top",
8652 at: "left" + (left >= 0 ? "+" : "") + left + " " +
8653 "top" + (top >= 0 ? "+" : "") + top,
8654 of: that.window
8655 };
8656 $( this ).removeClass( "ui-dialog-resizing" );
8657 that._unblockFrames();
8658 that._trigger( "resizeStop", event, filteredUi( ui ) );
8659 }
8660 })
8661 .css( "position", position );
8662 },
8663
8664 _trackFocus: function() {
8665 this._on( this.widget(), {
8666 focusin: function( event ) {
8667 this._makeFocusTarget();
8668 this._focusedElement = $( event.target );
8669 }
8670 });
8671 },
8672
8673 _makeFocusTarget: function() {
8674 this._untrackInstance();
8675 this._trackingInstances().unshift( this );
8676 },
8677
8678 _untrackInstance: function() {
8679 var instances = this._trackingInstances(),
8680 exists = $.inArray( this, instances );
8681 if ( exists !== -1 ) {
8682 instances.splice( exists, 1 );
8683 }
8684 },
8685
8686 _trackingInstances: function() {
8687 var instances = this.document.data( "ui-dialog-instances" );
8688 if ( !instances ) {
8689 instances = [];
8690 this.document.data( "ui-dialog-instances", instances );
8691 }
8692 return instances;
8693 },
8694
8695 _minHeight: function() {
8696 var options = this.options;
8697
8698 return options.height === "auto" ?
8699 options.minHeight :
8700 Math.min( options.minHeight, options.height );
8701 },
8702
8703 _position: function() {
8704 // Need to show the dialog to get the actual offset in the position plugin
8705 var isVisible = this.uiDialog.is( ":visible" );
8706 if ( !isVisible ) {
8707 this.uiDialog.show();
8708 }
8709 this.uiDialog.position( this.options.position );
8710 if ( !isVisible ) {
8711 this.uiDialog.hide();
8712 }
8713 },
8714
8715 _setOptions: function( options ) {
8716 var that = this,
8717 resize = false,
8718 resizableOptions = {};
8719
8720 $.each( options, function( key, value ) {
8721 that._setOption( key, value );
8722
8723 if ( key in that.sizeRelatedOptions ) {
8724 resize = true;
8725 }
8726 if ( key in that.resizableRelatedOptions ) {
8727 resizableOptions[ key ] = value;
8728 }
8729 });
8730
8731 if ( resize ) {
8732 this._size();
8733 this._position();
8734 }
8735 if ( this.uiDialog.is( ":data(ui-resizable)" ) ) {
8736 this.uiDialog.resizable( "option", resizableOptions );
8737 }
8738 },
8739
8740 _setOption: function( key, value ) {
8741 var isDraggable, isResizable,
8742 uiDialog = this.uiDialog;
8743
8744 if ( key === "dialogClass" ) {
8745 uiDialog
8746 .removeClass( this.options.dialogClass )
8747 .addClass( value );
8748 }
8749
8750 if ( key === "disabled" ) {
8751 return;
8752 }
8753
8754 this._super( key, value );
8755
8756 if ( key === "appendTo" ) {
8757 this.uiDialog.appendTo( this._appendTo() );
8758 }
8759
8760 if ( key === "buttons" ) {
8761 this._createButtons();
8762 }
8763
8764 if ( key === "closeText" ) {
8765 this.uiDialogTitlebarClose.button({
8766 // Ensure that we always pass a string
8767 label: "" + value
8768 });
8769 }
8770
8771 if ( key === "draggable" ) {
8772 isDraggable = uiDialog.is( ":data(ui-draggable)" );
8773 if ( isDraggable && !value ) {
8774 uiDialog.draggable( "destroy" );
8775 }
8776
8777 if ( !isDraggable && value ) {
8778 this._makeDraggable();
8779 }
8780 }
8781
8782 if ( key === "position" ) {
8783 this._position();
8784 }
8785
8786 if ( key === "resizable" ) {
8787 // currently resizable, becoming non-resizable
8788 isResizable = uiDialog.is( ":data(ui-resizable)" );
8789 if ( isResizable && !value ) {
8790 uiDialog.resizable( "destroy" );
8791 }
8792
8793 // currently resizable, changing handles
8794 if ( isResizable && typeof value === "string" ) {
8795 uiDialog.resizable( "option", "handles", value );
8796 }
8797
8798 // currently non-resizable, becoming resizable
8799 if ( !isResizable && value !== false ) {
8800 this._makeResizable();
8801 }
8802 }
8803
8804 if ( key === "title" ) {
8805 this._title( this.uiDialogTitlebar.find( ".ui-dialog-title" ) );
8806 }
8807 },
8808
8809 _size: function() {
8810 // If the user has resized the dialog, the .ui-dialog and .ui-dialog-content
8811 // divs will both have width and height set, so we need to reset them
8812 var nonContentHeight, minContentHeight, maxContentHeight,
8813 options = this.options;
8814
8815 // Reset content sizing
8816 this.element.show().css({
8817 width: "auto",
8818 minHeight: 0,
8819 maxHeight: "none",
8820 height: 0
8821 });
8822
8823 if ( options.minWidth > options.width ) {
8824 options.width = options.minWidth;
8825 }
8826
8827 // reset wrapper sizing
8828 // determine the height of all the non-content elements
8829 nonContentHeight = this.uiDialog.css({
8830 height: "auto",
8831 width: options.width
8832 })
8833 .outerHeight();
8834 minContentHeight = Math.max( 0, options.minHeight - nonContentHeight );
8835 maxContentHeight = typeof options.maxHeight === "number" ?
8836 Math.max( 0, options.maxHeight - nonContentHeight ) :
8837 "none";
8838
8839 if ( options.height === "auto" ) {
8840 this.element.css({
8841 minHeight: minContentHeight,
8842 maxHeight: maxContentHeight,
8843 height: "auto"
8844 });
8845 } else {
8846 this.element.height( Math.max( 0, options.height - nonContentHeight ) );
8847 }
8848
8849 if ( this.uiDialog.is( ":data(ui-resizable)" ) ) {
8850 this.uiDialog.resizable( "option", "minHeight", this._minHeight() );
8851 }
8852 },
8853
8854 _blockFrames: function() {
8855 this.iframeBlocks = this.document.find( "iframe" ).map(function() {
8856 var iframe = $( this );
8857
8858 return $( "<div>" )
8859 .css({
8860 position: "absolute",
8861 width: iframe.outerWidth(),
8862 height: iframe.outerHeight()
8863 })
8864 .appendTo( iframe.parent() )
8865 .offset( iframe.offset() )[0];
8866 });
8867 },
8868
8869 _unblockFrames: function() {
8870 if ( this.iframeBlocks ) {
8871 this.iframeBlocks.remove();
8872 delete this.iframeBlocks;
8873 }
8874 },
8875
8876 _allowInteraction: function( event ) {
8877 if ( $( event.target ).closest( ".ui-dialog" ).length ) {
8878 return true;
8879 }
8880
8881 // TODO: Remove hack when datepicker implements
8882 // the .ui-front logic (#8989)
8883 return !!$( event.target ).closest( ".ui-datepicker" ).length;
8884 },
8885
8886 _createOverlay: function() {
8887 if ( !this.options.modal ) {
8888 return;
8889 }
8890
8891 // We use a delay in case the overlay is created from an
8892 // event that we're going to be cancelling (#2804)
8893 var isOpening = true;
8894 this._delay(function() {
8895 isOpening = false;
8896 });
8897
8898 if ( !this.document.data( "ui-dialog-overlays" ) ) {
8899
8900 // Prevent use of anchors and inputs
8901 // Using _on() for an event handler shared across many instances is
8902 // safe because the dialogs stack and must be closed in reverse order
8903 this._on( this.document, {
8904 focusin: function( event ) {
8905 if ( isOpening ) {
8906 return;
8907 }
8908
8909 if ( !this._allowInteraction( event ) ) {
8910 event.preventDefault();
8911 this._trackingInstances()[ 0 ]._focusTabbable();
8912 }
8913 }
8914 });
8915 }
8916
8917 this.overlay = $( "<div>" )
8918 .addClass( "ui-widget-overlay ui-front" )
8919 .appendTo( this._appendTo() );
8920 this._on( this.overlay, {
8921 mousedown: "_keepFocus"
8922 });
8923 this.document.data( "ui-dialog-overlays",
8924 (this.document.data( "ui-dialog-overlays" ) || 0) + 1 );
8925 },
8926
8927 _destroyOverlay: function() {
8928 if ( !this.options.modal ) {
8929 return;
8930 }
8931
8932 if ( this.overlay ) {
8933 var overlays = this.document.data( "ui-dialog-overlays" ) - 1;
8934
8935 if ( !overlays ) {
8936 this.document
8937 .unbind( "focusin" )
8938 .removeData( "ui-dialog-overlays" );
8939 } else {
8940 this.document.data( "ui-dialog-overlays", overlays );
8941 }
8942
8943 this.overlay.remove();
8944 this.overlay = null;
8945 }
8946 }
8947 });
8948
8949
8950 /*!
8951 * jQuery UI Droppable 1.11.4
8952 * http://jqueryui.com
8953 *
8954 * Copyright jQuery Foundation and other contributors
8955 * Released under the MIT license.
8956 * http://jquery.org/license
8957 *
8958 * http://api.jqueryui.com/droppable/
8959 */
8960
8961
8962 $.widget( "ui.droppable", {
8963 version: "1.11.4",
8964 widgetEventPrefix: "drop",
8965 options: {
8966 accept: "*",
8967 activeClass: false,
8968 addClasses: true,
8969 greedy: false,
8970 hoverClass: false,
8971 scope: "default",
8972 tolerance: "intersect",
8973
8974 // callbacks
8975 activate: null,
8976 deactivate: null,
8977 drop: null,
8978 out: null,
8979 over: null
8980 },
8981 _create: function() {
8982
8983 var proportions,
8984 o = this.options,
8985 accept = o.accept;
8986
8987 this.isover = false;
8988 this.isout = true;
8989
8990 this.accept = $.isFunction( accept ) ? accept : function( d ) {
8991 return d.is( accept );
8992 };
8993
8994 this.proportions = function( /* valueToWrite */ ) {
8995 if ( arguments.length ) {
8996 // Store the droppable's proportions
8997 proportions = arguments[ 0 ];
8998 } else {
8999 // Retrieve or derive the droppable's proportions
9000 return proportions ?
9001 proportions :
9002 proportions = {
9003 width: this.element[ 0 ].offsetWidth,
9004 height: this.element[ 0 ].offsetHeight
9005 };
9006 }
9007 };
9008
9009 this._addToManager( o.scope );
9010
9011 o.addClasses && this.element.addClass( "ui-droppable" );
9012
9013 },
9014
9015 _addToManager: function( scope ) {
9016 // Add the reference and positions to the manager
9017 $.ui.ddmanager.droppables[ scope ] = $.ui.ddmanager.droppables[ scope ] || [];
9018 $.ui.ddmanager.droppables[ scope ].push( this );
9019 },
9020
9021 _splice: function( drop ) {
9022 var i = 0;
9023 for ( ; i < drop.length; i++ ) {
9024 if ( drop[ i ] === this ) {
9025 drop.splice( i, 1 );
9026 }
9027 }
9028 },
9029
9030 _destroy: function() {
9031 var drop = $.ui.ddmanager.droppables[ this.options.scope ];
9032
9033 this._splice( drop );
9034
9035 this.element.removeClass( "ui-droppable ui-droppable-disabled" );
9036 },
9037
9038 _setOption: function( key, value ) {
9039
9040 if ( key === "accept" ) {
9041 this.accept = $.isFunction( value ) ? value : function( d ) {
9042 return d.is( value );
9043 };
9044 } else if ( key === "scope" ) {
9045 var drop = $.ui.ddmanager.droppables[ this.options.scope ];
9046
9047 this._splice( drop );
9048 this._addToManager( value );
9049 }
9050
9051 this._super( key, value );
9052 },
9053
9054 _activate: function( event ) {
9055 var draggable = $.ui.ddmanager.current;
9056 if ( this.options.activeClass ) {
9057 this.element.addClass( this.options.activeClass );
9058 }
9059 if ( draggable ){
9060 this._trigger( "activate", event, this.ui( draggable ) );
9061 }
9062 },
9063
9064 _deactivate: function( event ) {
9065 var draggable = $.ui.ddmanager.current;
9066 if ( this.options.activeClass ) {
9067 this.element.removeClass( this.options.activeClass );
9068 }
9069 if ( draggable ){
9070 this._trigger( "deactivate", event, this.ui( draggable ) );
9071 }
9072 },
9073
9074 _over: function( event ) {
9075
9076 var draggable = $.ui.ddmanager.current;
9077
9078 // Bail if draggable and droppable are same element
9079 if ( !draggable || ( draggable.currentItem || draggable.element )[ 0 ] === this.element[ 0 ] ) {
9080 return;
9081 }
9082
9083 if ( this.accept.call( this.element[ 0 ], ( draggable.currentItem || draggable.element ) ) ) {
9084 if ( this.options.hoverClass ) {
9085 this.element.addClass( this.options.hoverClass );
9086 }
9087 this._trigger( "over", event, this.ui( draggable ) );
9088 }
9089
9090 },
9091
9092 _out: function( event ) {
9093
9094 var draggable = $.ui.ddmanager.current;
9095
9096 // Bail if draggable and droppable are same element
9097 if ( !draggable || ( draggable.currentItem || draggable.element )[ 0 ] === this.element[ 0 ] ) {
9098 return;
9099 }
9100
9101 if ( this.accept.call( this.element[ 0 ], ( draggable.currentItem || draggable.element ) ) ) {
9102 if ( this.options.hoverClass ) {
9103 this.element.removeClass( this.options.hoverClass );
9104 }
9105 this._trigger( "out", event, this.ui( draggable ) );
9106 }
9107
9108 },
9109
9110 _drop: function( event, custom ) {
9111
9112 var draggable = custom || $.ui.ddmanager.current,
9113 childrenIntersection = false;
9114
9115 // Bail if draggable and droppable are same element
9116 if ( !draggable || ( draggable.currentItem || draggable.element )[ 0 ] === this.element[ 0 ] ) {
9117 return false;
9118 }
9119
9120 this.element.find( ":data(ui-droppable)" ).not( ".ui-draggable-dragging" ).each(function() {
9121 var inst = $( this ).droppable( "instance" );
9122 if (
9123 inst.options.greedy &&
9124 !inst.options.disabled &&
9125 inst.options.scope === draggable.options.scope &&
9126 inst.accept.call( inst.element[ 0 ], ( draggable.currentItem || draggable.element ) ) &&
9127 $.ui.intersect( draggable, $.extend( inst, { offset: inst.element.offset() } ), inst.options.tolerance, event )
9128 ) { childrenIntersection = true; return false; }
9129 });
9130 if ( childrenIntersection ) {
9131 return false;
9132 }
9133
9134 if ( this.accept.call( this.element[ 0 ], ( draggable.currentItem || draggable.element ) ) ) {
9135 if ( this.options.activeClass ) {
9136 this.element.removeClass( this.options.activeClass );
9137 }
9138 if ( this.options.hoverClass ) {
9139 this.element.removeClass( this.options.hoverClass );
9140 }
9141 this._trigger( "drop", event, this.ui( draggable ) );
9142 return this.element;
9143 }
9144
9145 return false;
9146
9147 },
9148
9149 ui: function( c ) {
9150 return {
9151 draggable: ( c.currentItem || c.element ),
9152 helper: c.helper,
9153 position: c.position,
9154 offset: c.positionAbs
9155 };
9156 }
9157
9158 });
9159
9160 $.ui.intersect = (function() {
9161 function isOverAxis( x, reference, size ) {
9162 return ( x >= reference ) && ( x < ( reference + size ) );
9163 }
9164
9165 return function( draggable, droppable, toleranceMode, event ) {
9166
9167 if ( !droppable.offset ) {
9168 return false;
9169 }
9170
9171 var x1 = ( draggable.positionAbs || draggable.position.absolute ).left + draggable.margins.left,
9172 y1 = ( draggable.positionAbs || draggable.position.absolute ).top + draggable.margins.top,
9173 x2 = x1 + draggable.helperProportions.width,
9174 y2 = y1 + draggable.helperProportions.height,
9175 l = droppable.offset.left,
9176 t = droppable.offset.top,
9177 r = l + droppable.proportions().width,
9178 b = t + droppable.proportions().height;
9179
9180 switch ( toleranceMode ) {
9181 case "fit":
9182 return ( l <= x1 && x2 <= r && t <= y1 && y2 <= b );
9183 case "intersect":
9184 return ( l < x1 + ( draggable.helperProportions.width / 2 ) && // Right Half
9185 x2 - ( draggable.helperProportions.width / 2 ) < r && // Left Half
9186 t < y1 + ( draggable.helperProportions.height / 2 ) && // Bottom Half
9187 y2 - ( draggable.helperProportions.height / 2 ) < b ); // Top Half
9188 case "pointer":
9189 return isOverAxis( event.pageY, t, droppable.proportions().height ) && isOverAxis( event.pageX, l, droppable.proportions().width );
9190 case "touch":
9191 return (
9192 ( y1 >= t && y1 <= b ) || // Top edge touching
9193 ( y2 >= t && y2 <= b ) || // Bottom edge touching
9194 ( y1 < t && y2 > b ) // Surrounded vertically
9195 ) && (
9196 ( x1 >= l && x1 <= r ) || // Left edge touching
9197 ( x2 >= l && x2 <= r ) || // Right edge touching
9198 ( x1 < l && x2 > r ) // Surrounded horizontally
9199 );
9200 default:
9201 return false;
9202 }
9203 };
9204 })();
9205
9206 /*
9207 This manager tracks offsets of draggables and droppables
9208 */
9209 $.ui.ddmanager = {
9210 current: null,
9211 droppables: { "default": [] },
9212 prepareOffsets: function( t, event ) {
9213
9214 var i, j,
9215 m = $.ui.ddmanager.droppables[ t.options.scope ] || [],
9216 type = event ? event.type : null, // workaround for #2317
9217 list = ( t.currentItem || t.element ).find( ":data(ui-droppable)" ).addBack();
9218
9219 droppablesLoop: for ( i = 0; i < m.length; i++ ) {
9220
9221 // No disabled and non-accepted
9222 if ( m[ i ].options.disabled || ( t && !m[ i ].accept.call( m[ i ].element[ 0 ], ( t.currentItem || t.element ) ) ) ) {
9223 continue;
9224 }
9225
9226 // Filter out elements in the current dragged item
9227 for ( j = 0; j < list.length; j++ ) {
9228 if ( list[ j ] === m[ i ].element[ 0 ] ) {
9229 m[ i ].proportions().height = 0;
9230 continue droppablesLoop;
9231 }
9232 }
9233
9234 m[ i ].visible = m[ i ].element.css( "display" ) !== "none";
9235 if ( !m[ i ].visible ) {
9236 continue;
9237 }
9238
9239 // Activate the droppable if used directly from draggables
9240 if ( type === "mousedown" ) {
9241 m[ i ]._activate.call( m[ i ], event );
9242 }
9243
9244 m[ i ].offset = m[ i ].element.offset();
9245 m[ i ].proportions({ width: m[ i ].element[ 0 ].offsetWidth, height: m[ i ].element[ 0 ].offsetHeight });
9246
9247 }
9248
9249 },
9250 drop: function( draggable, event ) {
9251
9252 var dropped = false;
9253 // Create a copy of the droppables in case the list changes during the drop (#9116)
9254 $.each( ( $.ui.ddmanager.droppables[ draggable.options.scope ] || [] ).slice(), function() {
9255
9256 if ( !this.options ) {
9257 return;
9258 }
9259 if ( !this.options.disabled && this.visible && $.ui.intersect( draggable, this, this.options.tolerance, event ) ) {
9260 dropped = this._drop.call( this, event ) || dropped;
9261 }
9262
9263 if ( !this.options.disabled && this.visible && this.accept.call( this.element[ 0 ], ( draggable.currentItem || draggable.element ) ) ) {
9264 this.isout = true;
9265 this.isover = false;
9266 this._deactivate.call( this, event );
9267 }
9268
9269 });
9270 return dropped;
9271
9272 },
9273 dragStart: function( draggable, event ) {
9274 // Listen for scrolling so that if the dragging causes scrolling the position of the droppables can be recalculated (see #5003)
9275 draggable.element.parentsUntil( "body" ).bind( "scroll.droppable", function() {
9276 if ( !draggable.options.refreshPositions ) {
9277 $.ui.ddmanager.prepareOffsets( draggable, event );
9278 }
9279 });
9280 },
9281 drag: function( draggable, event ) {
9282
9283 // If you have a highly dynamic page, you might try this option. It renders positions every time you move the mouse.
9284 if ( draggable.options.refreshPositions ) {
9285 $.ui.ddmanager.prepareOffsets( draggable, event );
9286 }
9287
9288 // Run through all droppables and check their positions based on specific tolerance options
9289 $.each( $.ui.ddmanager.droppables[ draggable.options.scope ] || [], function() {
9290
9291 if ( this.options.disabled || this.greedyChild || !this.visible ) {
9292 return;
9293 }
9294
9295 var parentInstance, scope, parent,
9296 intersects = $.ui.intersect( draggable, this, this.options.tolerance, event ),
9297 c = !intersects && this.isover ? "isout" : ( intersects && !this.isover ? "isover" : null );
9298 if ( !c ) {
9299 return;
9300 }
9301
9302 if ( this.options.greedy ) {
9303 // find droppable parents with same scope
9304 scope = this.options.scope;
9305 parent = this.element.parents( ":data(ui-droppable)" ).filter(function() {
9306 return $( this ).droppable( "instance" ).options.scope === scope;
9307 });
9308
9309 if ( parent.length ) {
9310 parentInstance = $( parent[ 0 ] ).droppable( "instance" );
9311 parentInstance.greedyChild = ( c === "isover" );
9312 }
9313 }
9314
9315 // we just moved into a greedy child
9316 if ( parentInstance && c === "isover" ) {
9317 parentInstance.isover = false;
9318 parentInstance.isout = true;
9319 parentInstance._out.call( parentInstance, event );
9320 }
9321
9322 this[ c ] = true;
9323 this[c === "isout" ? "isover" : "isout"] = false;
9324 this[c === "isover" ? "_over" : "_out"].call( this, event );
9325
9326 // we just moved out of a greedy child
9327 if ( parentInstance && c === "isout" ) {
9328 parentInstance.isout = false;
9329 parentInstance.isover = true;
9330 parentInstance._over.call( parentInstance, event );
9331 }
9332 });
9333
9334 },
9335 dragStop: function( draggable, event ) {
9336 draggable.element.parentsUntil( "body" ).unbind( "scroll.droppable" );
9337 // Call prepareOffsets one final time since IE does not fire return scroll events when overflow was caused by drag (see #5003)
9338 if ( !draggable.options.refreshPositions ) {
9339 $.ui.ddmanager.prepareOffsets( draggable, event );
9340 }
9341 }
9342 };
9343
9344 var droppable = $.ui.droppable;
9345
9346
9347 /*!
9348 * jQuery UI Effects 1.11.4
9349 * http://jqueryui.com
9350 *
9351 * Copyright jQuery Foundation and other contributors
9352 * Released under the MIT license.
9353 * http://jquery.org/license
9354 *
9355 * http://api.jqueryui.com/category/effects-core/
9356 */
9357
9358
9359 var dataSpace = "ui-effects-",
9360
9361 // Create a local jQuery because jQuery Color relies on it and the
9362 // global may not exist with AMD and a custom build (#10199)
9363 jQuery = $;
9364
9365 $.effects = {
9366 effect: {}
9367 };
9368
9369 /*!
9370 * jQuery Color Animations v2.1.2
9371 * https://github.com/jquery/jquery-color
9372 *
9373 * Copyright 2014 jQuery Foundation and other contributors
9374 * Released under the MIT license.
9375 * http://jquery.org/license
9376 *
9377 * Date: Wed Jan 16 08:47:09 2013 -0600
9378 */
9379 (function( jQuery, undefined ) {
9380
9381 var stepHooks = "backgroundColor borderBottomColor borderLeftColor borderRightColor borderTopColor color columnRuleColor outlineColor textDecorationColor textEmphasisColor",
9382
9383 // plusequals test for += 100 -= 100
9384 rplusequals = /^([\-+])=\s*(\d+\.?\d*)/,
9385 // a set of RE's that can match strings and generate color tuples.
9386 stringParsers = [ {
9387 re: /rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
9388 parse: function( execResult ) {
9389 return [
9390 execResult[ 1 ],
9391 execResult[ 2 ],
9392 execResult[ 3 ],
9393 execResult[ 4 ]
9394 ];
9395 }
9396 }, {
9397 re: /rgba?\(\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
9398 parse: function( execResult ) {
9399 return [
9400 execResult[ 1 ] * 2.55,
9401 execResult[ 2 ] * 2.55,
9402 execResult[ 3 ] * 2.55,
9403 execResult[ 4 ]
9404 ];
9405 }
9406 }, {
9407 // this regex ignores A-F because it's compared against an already lowercased string
9408 re: /#([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})/,
9409 parse: function( execResult ) {
9410 return [
9411 parseInt( execResult[ 1 ], 16 ),
9412 parseInt( execResult[ 2 ], 16 ),
9413 parseInt( execResult[ 3 ], 16 )
9414 ];
9415 }
9416 }, {
9417 // this regex ignores A-F because it's compared against an already lowercased string
9418 re: /#([a-f0-9])([a-f0-9])([a-f0-9])/,
9419 parse: function( execResult ) {
9420 return [
9421 parseInt( execResult[ 1 ] + execResult[ 1 ], 16 ),
9422 parseInt( execResult[ 2 ] + execResult[ 2 ], 16 ),
9423 parseInt( execResult[ 3 ] + execResult[ 3 ], 16 )
9424 ];
9425 }
9426 }, {
9427 re: /hsla?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
9428 space: "hsla",
9429 parse: function( execResult ) {
9430 return [
9431 execResult[ 1 ],
9432 execResult[ 2 ] / 100,
9433 execResult[ 3 ] / 100,
9434 execResult[ 4 ]
9435 ];
9436 }
9437 } ],
9438
9439 // jQuery.Color( )
9440 color = jQuery.Color = function( color, green, blue, alpha ) {
9441 return new jQuery.Color.fn.parse( color, green, blue, alpha );
9442 },
9443 spaces = {
9444 rgba: {
9445 props: {
9446 red: {
9447 idx: 0,
9448 type: "byte"
9449 },
9450 green: {
9451 idx: 1,
9452 type: "byte"
9453 },
9454 blue: {
9455 idx: 2,
9456 type: "byte"
9457 }
9458 }
9459 },
9460
9461 hsla: {
9462 props: {
9463 hue: {
9464 idx: 0,
9465 type: "degrees"
9466 },
9467 saturation: {
9468 idx: 1,
9469 type: "percent"
9470 },
9471 lightness: {
9472 idx: 2,
9473 type: "percent"
9474 }
9475 }
9476 }
9477 },
9478 propTypes = {
9479 "byte": {
9480 floor: true,
9481 max: 255
9482 },
9483 "percent": {
9484 max: 1
9485 },
9486 "degrees": {
9487 mod: 360,
9488 floor: true
9489 }
9490 },
9491 support = color.support = {},
9492
9493 // element for support tests
9494 supportElem = jQuery( "<p>" )[ 0 ],
9495
9496 // colors = jQuery.Color.names
9497 colors,
9498
9499 // local aliases of functions called often
9500 each = jQuery.each;
9501
9502 // determine rgba support immediately
9503 supportElem.style.cssText = "background-color:rgba(1,1,1,.5)";
9504 support.rgba = supportElem.style.backgroundColor.indexOf( "rgba" ) > -1;
9505
9506 // define cache name and alpha properties
9507 // for rgba and hsla spaces
9508 each( spaces, function( spaceName, space ) {
9509 space.cache = "_" + spaceName;
9510 space.props.alpha = {
9511 idx: 3,
9512 type: "percent",
9513 def: 1
9514 };
9515 });
9516
9517 function clamp( value, prop, allowEmpty ) {
9518 var type = propTypes[ prop.type ] || {};
9519
9520 if ( value == null ) {
9521 return (allowEmpty || !prop.def) ? null : prop.def;
9522 }
9523
9524 // ~~ is an short way of doing floor for positive numbers
9525 value = type.floor ? ~~value : parseFloat( value );
9526
9527 // IE will pass in empty strings as value for alpha,
9528 // which will hit this case
9529 if ( isNaN( value ) ) {
9530 return prop.def;
9531 }
9532
9533 if ( type.mod ) {
9534 // we add mod before modding to make sure that negatives values
9535 // get converted properly: -10 -> 350
9536 return (value + type.mod) % type.mod;
9537 }
9538
9539 // for now all property types without mod have min and max
9540 return 0 > value ? 0 : type.max < value ? type.max : value;
9541 }
9542
9543 function stringParse( string ) {
9544 var inst = color(),
9545 rgba = inst._rgba = [];
9546
9547 string = string.toLowerCase();
9548
9549 each( stringParsers, function( i, parser ) {
9550 var parsed,
9551 match = parser.re.exec( string ),
9552 values = match && parser.parse( match ),
9553 spaceName = parser.space || "rgba";
9554
9555 if ( values ) {
9556 parsed = inst[ spaceName ]( values );
9557
9558 // if this was an rgba parse the assignment might happen twice
9559 // oh well....
9560 inst[ spaces[ spaceName ].cache ] = parsed[ spaces[ spaceName ].cache ];
9561 rgba = inst._rgba = parsed._rgba;
9562
9563 // exit each( stringParsers ) here because we matched
9564 return false;
9565 }
9566 });
9567
9568 // Found a stringParser that handled it
9569 if ( rgba.length ) {
9570
9571 // if this came from a parsed string, force "transparent" when alpha is 0
9572 // chrome, (and maybe others) return "transparent" as rgba(0,0,0,0)
9573 if ( rgba.join() === "0,0,0,0" ) {
9574 jQuery.extend( rgba, colors.transparent );
9575 }
9576 return inst;
9577 }
9578
9579 // named colors
9580 return colors[ string ];
9581 }
9582
9583 color.fn = jQuery.extend( color.prototype, {
9584 parse: function( red, green, blue, alpha ) {
9585 if ( red === undefined ) {
9586 this._rgba = [ null, null, null, null ];
9587 return this;
9588 }
9589 if ( red.jquery || red.nodeType ) {
9590 red = jQuery( red ).css( green );
9591 green = undefined;
9592 }
9593
9594 var inst = this,
9595 type = jQuery.type( red ),
9596 rgba = this._rgba = [];
9597
9598 // more than 1 argument specified - assume ( red, green, blue, alpha )
9599 if ( green !== undefined ) {
9600 red = [ red, green, blue, alpha ];
9601 type = "array";
9602 }
9603
9604 if ( type === "string" ) {
9605 return this.parse( stringParse( red ) || colors._default );
9606 }
9607
9608 if ( type === "array" ) {
9609 each( spaces.rgba.props, function( key, prop ) {
9610 rgba[ prop.idx ] = clamp( red[ prop.idx ], prop );
9611 });
9612 return this;
9613 }
9614
9615 if ( type === "object" ) {
9616 if ( red instanceof color ) {
9617 each( spaces, function( spaceName, space ) {
9618 if ( red[ space.cache ] ) {
9619 inst[ space.cache ] = red[ space.cache ].slice();
9620 }
9621 });
9622 } else {
9623 each( spaces, function( spaceName, space ) {
9624 var cache = space.cache;
9625 each( space.props, function( key, prop ) {
9626
9627 // if the cache doesn't exist, and we know how to convert
9628 if ( !inst[ cache ] && space.to ) {
9629
9630 // if the value was null, we don't need to copy it
9631 // if the key was alpha, we don't need to copy it either
9632 if ( key === "alpha" || red[ key ] == null ) {
9633 return;
9634 }
9635 inst[ cache ] = space.to( inst._rgba );
9636 }
9637
9638 // this is the only case where we allow nulls for ALL properties.
9639 // call clamp with alwaysAllowEmpty
9640 inst[ cache ][ prop.idx ] = clamp( red[ key ], prop, true );
9641 });
9642
9643 // everything defined but alpha?
9644 if ( inst[ cache ] && jQuery.inArray( null, inst[ cache ].slice( 0, 3 ) ) < 0 ) {
9645 // use the default of 1
9646 inst[ cache ][ 3 ] = 1;
9647 if ( space.from ) {
9648 inst._rgba = space.from( inst[ cache ] );
9649 }
9650 }
9651 });
9652 }
9653 return this;
9654 }
9655 },
9656 is: function( compare ) {
9657 var is = color( compare ),
9658 same = true,
9659 inst = this;
9660
9661 each( spaces, function( _, space ) {
9662 var localCache,
9663 isCache = is[ space.cache ];
9664 if (isCache) {
9665 localCache = inst[ space.cache ] || space.to && space.to( inst._rgba ) || [];
9666 each( space.props, function( _, prop ) {
9667 if ( isCache[ prop.idx ] != null ) {
9668 same = ( isCache[ prop.idx ] === localCache[ prop.idx ] );
9669 return same;
9670 }
9671 });
9672 }
9673 return same;
9674 });
9675 return same;
9676 },
9677 _space: function() {
9678 var used = [],
9679 inst = this;
9680 each( spaces, function( spaceName, space ) {
9681 if ( inst[ space.cache ] ) {
9682 used.push( spaceName );
9683 }
9684 });
9685 return used.pop();
9686 },
9687 transition: function( other, distance ) {
9688 var end = color( other ),
9689 spaceName = end._space(),
9690 space = spaces[ spaceName ],
9691 startColor = this.alpha() === 0 ? color( "transparent" ) : this,
9692 start = startColor[ space.cache ] || space.to( startColor._rgba ),
9693 result = start.slice();
9694
9695 end = end[ space.cache ];
9696 each( space.props, function( key, prop ) {
9697 var index = prop.idx,
9698 startValue = start[ index ],
9699 endValue = end[ index ],
9700 type = propTypes[ prop.type ] || {};
9701
9702 // if null, don't override start value
9703 if ( endValue === null ) {
9704 return;
9705 }
9706 // if null - use end
9707 if ( startValue === null ) {
9708 result[ index ] = endValue;
9709 } else {
9710 if ( type.mod ) {
9711 if ( endValue - startValue > type.mod / 2 ) {
9712 startValue += type.mod;
9713 } else if ( startValue - endValue > type.mod / 2 ) {
9714 startValue -= type.mod;
9715 }
9716 }
9717 result[ index ] = clamp( ( endValue - startValue ) * distance + startValue, prop );
9718 }
9719 });
9720 return this[ spaceName ]( result );
9721 },
9722 blend: function( opaque ) {
9723 // if we are already opaque - return ourself
9724 if ( this._rgba[ 3 ] === 1 ) {
9725 return this;
9726 }
9727
9728 var rgb = this._rgba.slice(),
9729 a = rgb.pop(),
9730 blend = color( opaque )._rgba;
9731
9732 return color( jQuery.map( rgb, function( v, i ) {
9733 return ( 1 - a ) * blend[ i ] + a * v;
9734 }));
9735 },
9736 toRgbaString: function() {
9737 var prefix = "rgba(",
9738 rgba = jQuery.map( this._rgba, function( v, i ) {
9739 return v == null ? ( i > 2 ? 1 : 0 ) : v;
9740 });
9741
9742 if ( rgba[ 3 ] === 1 ) {
9743 rgba.pop();
9744 prefix = "rgb(";
9745 }
9746
9747 return prefix + rgba.join() + ")";
9748 },
9749 toHslaString: function() {
9750 var prefix = "hsla(",
9751 hsla = jQuery.map( this.hsla(), function( v, i ) {
9752 if ( v == null ) {
9753 v = i > 2 ? 1 : 0;
9754 }
9755
9756 // catch 1 and 2
9757 if ( i && i < 3 ) {
9758 v = Math.round( v * 100 ) + "%";
9759 }
9760 return v;
9761 });
9762
9763 if ( hsla[ 3 ] === 1 ) {
9764 hsla.pop();
9765 prefix = "hsl(";
9766 }
9767 return prefix + hsla.join() + ")";
9768 },
9769 toHexString: function( includeAlpha ) {
9770 var rgba = this._rgba.slice(),
9771 alpha = rgba.pop();
9772
9773 if ( includeAlpha ) {
9774 rgba.push( ~~( alpha * 255 ) );
9775 }
9776
9777 return "#" + jQuery.map( rgba, function( v ) {
9778
9779 // default to 0 when nulls exist
9780 v = ( v || 0 ).toString( 16 );
9781 return v.length === 1 ? "0" + v : v;
9782 }).join("");
9783 },
9784 toString: function() {
9785 return this._rgba[ 3 ] === 0 ? "transparent" : this.toRgbaString();
9786 }
9787 });
9788 color.fn.parse.prototype = color.fn;
9789
9790 // hsla conversions adapted from:
9791 // https://code.google.com/p/maashaack/source/browse/packages/graphics/trunk/src/graphics/colors/HUE2RGB.as?r=5021
9792
9793 function hue2rgb( p, q, h ) {
9794 h = ( h + 1 ) % 1;
9795 if ( h * 6 < 1 ) {
9796 return p + ( q - p ) * h * 6;
9797 }
9798 if ( h * 2 < 1) {
9799 return q;
9800 }
9801 if ( h * 3 < 2 ) {
9802 return p + ( q - p ) * ( ( 2 / 3 ) - h ) * 6;
9803 }
9804 return p;
9805 }
9806
9807 spaces.hsla.to = function( rgba ) {
9808 if ( rgba[ 0 ] == null || rgba[ 1 ] == null || rgba[ 2 ] == null ) {
9809 return [ null, null, null, rgba[ 3 ] ];
9810 }
9811 var r = rgba[ 0 ] / 255,
9812 g = rgba[ 1 ] / 255,
9813 b = rgba[ 2 ] / 255,
9814 a = rgba[ 3 ],
9815 max = Math.max( r, g, b ),
9816 min = Math.min( r, g, b ),
9817 diff = max - min,
9818 add = max + min,
9819 l = add * 0.5,
9820 h, s;
9821
9822 if ( min === max ) {
9823 h = 0;
9824 } else if ( r === max ) {
9825 h = ( 60 * ( g - b ) / diff ) + 360;
9826 } else if ( g === max ) {
9827 h = ( 60 * ( b - r ) / diff ) + 120;
9828 } else {
9829 h = ( 60 * ( r - g ) / diff ) + 240;
9830 }
9831
9832 // chroma (diff) == 0 means greyscale which, by definition, saturation = 0%
9833 // otherwise, saturation is based on the ratio of chroma (diff) to lightness (add)
9834 if ( diff === 0 ) {
9835 s = 0;
9836 } else if ( l <= 0.5 ) {
9837 s = diff / add;
9838 } else {
9839 s = diff / ( 2 - add );
9840 }
9841 return [ Math.round(h) % 360, s, l, a == null ? 1 : a ];
9842 };
9843
9844 spaces.hsla.from = function( hsla ) {
9845 if ( hsla[ 0 ] == null || hsla[ 1 ] == null || hsla[ 2 ] == null ) {
9846 return [ null, null, null, hsla[ 3 ] ];
9847 }
9848 var h = hsla[ 0 ] / 360,
9849 s = hsla[ 1 ],
9850 l = hsla[ 2 ],
9851 a = hsla[ 3 ],
9852 q = l <= 0.5 ? l * ( 1 + s ) : l + s - l * s,
9853 p = 2 * l - q;
9854
9855 return [
9856 Math.round( hue2rgb( p, q, h + ( 1 / 3 ) ) * 255 ),
9857 Math.round( hue2rgb( p, q, h ) * 255 ),
9858 Math.round( hue2rgb( p, q, h - ( 1 / 3 ) ) * 255 ),
9859 a
9860 ];
9861 };
9862
9863 each( spaces, function( spaceName, space ) {
9864 var props = space.props,
9865 cache = space.cache,
9866 to = space.to,
9867 from = space.from;
9868
9869 // makes rgba() and hsla()
9870 color.fn[ spaceName ] = function( value ) {
9871
9872 // generate a cache for this space if it doesn't exist
9873 if ( to && !this[ cache ] ) {
9874 this[ cache ] = to( this._rgba );
9875 }
9876 if ( value === undefined ) {
9877 return this[ cache ].slice();
9878 }
9879
9880 var ret,
9881 type = jQuery.type( value ),
9882 arr = ( type === "array" || type === "object" ) ? value : arguments,
9883 local = this[ cache ].slice();
9884
9885 each( props, function( key, prop ) {
9886 var val = arr[ type === "object" ? key : prop.idx ];
9887 if ( val == null ) {
9888 val = local[ prop.idx ];
9889 }
9890 local[ prop.idx ] = clamp( val, prop );
9891 });
9892
9893 if ( from ) {
9894 ret = color( from( local ) );
9895 ret[ cache ] = local;
9896 return ret;
9897 } else {
9898 return color( local );
9899 }
9900 };
9901
9902 // makes red() green() blue() alpha() hue() saturation() lightness()
9903 each( props, function( key, prop ) {
9904 // alpha is included in more than one space
9905 if ( color.fn[ key ] ) {
9906 return;
9907 }
9908 color.fn[ key ] = function( value ) {
9909 var vtype = jQuery.type( value ),
9910 fn = ( key === "alpha" ? ( this._hsla ? "hsla" : "rgba" ) : spaceName ),
9911 local = this[ fn ](),
9912 cur = local[ prop.idx ],
9913 match;
9914
9915 if ( vtype === "undefined" ) {
9916 return cur;
9917 }
9918
9919 if ( vtype === "function" ) {
9920 value = value.call( this, cur );
9921 vtype = jQuery.type( value );
9922 }
9923 if ( value == null && prop.empty ) {
9924 return this;
9925 }
9926 if ( vtype === "string" ) {
9927 match = rplusequals.exec( value );
9928 if ( match ) {
9929 value = cur + parseFloat( match[ 2 ] ) * ( match[ 1 ] === "+" ? 1 : -1 );
9930 }
9931 }
9932 local[ prop.idx ] = value;
9933 return this[ fn ]( local );
9934 };
9935 });
9936 });
9937
9938 // add cssHook and .fx.step function for each named hook.
9939 // accept a space separated string of properties
9940 color.hook = function( hook ) {
9941 var hooks = hook.split( " " );
9942 each( hooks, function( i, hook ) {
9943 jQuery.cssHooks[ hook ] = {
9944 set: function( elem, value ) {
9945 var parsed, curElem,
9946 backgroundColor = "";
9947
9948 if ( value !== "transparent" && ( jQuery.type( value ) !== "string" || ( parsed = stringParse( value ) ) ) ) {
9949 value = color( parsed || value );
9950 if ( !support.rgba && value._rgba[ 3 ] !== 1 ) {
9951 curElem = hook === "backgroundColor" ? elem.parentNode : elem;
9952 while (
9953 (backgroundColor === "" || backgroundColor === "transparent") &&
9954 curElem && curElem.style
9955 ) {
9956 try {
9957 backgroundColor = jQuery.css( curElem, "backgroundColor" );
9958 curElem = curElem.parentNode;
9959 } catch ( e ) {
9960 }
9961 }
9962
9963 value = value.blend( backgroundColor && backgroundColor !== "transparent" ?
9964 backgroundColor :
9965 "_default" );
9966 }
9967
9968 value = value.toRgbaString();
9969 }
9970 try {
9971 elem.style[ hook ] = value;
9972 } catch ( e ) {
9973 // wrapped to prevent IE from throwing errors on "invalid" values like 'auto' or 'inherit'
9974 }
9975 }
9976 };
9977 jQuery.fx.step[ hook ] = function( fx ) {
9978 if ( !fx.colorInit ) {
9979 fx.start = color( fx.elem, hook );
9980 fx.end = color( fx.end );
9981 fx.colorInit = true;
9982 }
9983 jQuery.cssHooks[ hook ].set( fx.elem, fx.start.transition( fx.end, fx.pos ) );
9984 };
9985 });
9986
9987 };
9988
9989 color.hook( stepHooks );
9990
9991 jQuery.cssHooks.borderColor = {
9992 expand: function( value ) {
9993 var expanded = {};
9994
9995 each( [ "Top", "Right", "Bottom", "Left" ], function( i, part ) {
9996 expanded[ "border" + part + "Color" ] = value;
9997 });
9998 return expanded;
9999 }
10000 };
10001
10002 // Basic color names only.
10003 // Usage of any of the other color names requires adding yourself or including
10004 // jquery.color.svg-names.js.
10005 colors = jQuery.Color.names = {
10006 // 4.1. Basic color keywords
10007 aqua: "#00ffff",
10008 black: "#000000",
10009 blue: "#0000ff",
10010 fuchsia: "#ff00ff",
10011 gray: "#808080",
10012 green: "#008000",
10013 lime: "#00ff00",
10014 maroon: "#800000",
10015 navy: "#000080",
10016 olive: "#808000",
10017 purple: "#800080",
10018 red: "#ff0000",
10019 silver: "#c0c0c0",
10020 teal: "#008080",
10021 white: "#ffffff",
10022 yellow: "#ffff00",
10023
10024 // 4.2.3. "transparent" color keyword
10025 transparent: [ null, null, null, 0 ],
10026
10027 _default: "#ffffff"
10028 };
10029
10030 })( jQuery );
10031
10032 /******************************************************************************/
10033 /****************************** CLASS ANIMATIONS ******************************/
10034 /******************************************************************************/
10035 (function() {
10036
10037 var classAnimationActions = [ "add", "remove", "toggle" ],
10038 shorthandStyles = {
10039 border: 1,
10040 borderBottom: 1,
10041 borderColor: 1,
10042 borderLeft: 1,
10043 borderRight: 1,
10044 borderTop: 1,
10045 borderWidth: 1,
10046 margin: 1,
10047 padding: 1
10048 };
10049
10050 $.each([ "borderLeftStyle", "borderRightStyle", "borderBottomStyle", "borderTopStyle" ], function( _, prop ) {
10051 $.fx.step[ prop ] = function( fx ) {
10052 if ( fx.end !== "none" && !fx.setAttr || fx.pos === 1 && !fx.setAttr ) {
10053 jQuery.style( fx.elem, prop, fx.end );
10054 fx.setAttr = true;
10055 }
10056 };
10057 });
10058
10059 function getElementStyles( elem ) {
10060 var key, len,
10061 style = elem.ownerDocument.defaultView ?
10062 elem.ownerDocument.defaultView.getComputedStyle( elem, null ) :
10063 elem.currentStyle,
10064 styles = {};
10065
10066 if ( style && style.length && style[ 0 ] && style[ style[ 0 ] ] ) {
10067 len = style.length;
10068 while ( len-- ) {
10069 key = style[ len ];
10070 if ( typeof style[ key ] === "string" ) {
10071 styles[ $.camelCase( key ) ] = style[ key ];
10072 }
10073 }
10074 // support: Opera, IE <9
10075 } else {
10076 for ( key in style ) {
10077 if ( typeof style[ key ] === "string" ) {
10078 styles[ key ] = style[ key ];
10079 }
10080 }
10081 }
10082
10083 return styles;
10084 }
10085
10086 function styleDifference( oldStyle, newStyle ) {
10087 var diff = {},
10088 name, value;
10089
10090 for ( name in newStyle ) {
10091 value = newStyle[ name ];
10092 if ( oldStyle[ name ] !== value ) {
10093 if ( !shorthandStyles[ name ] ) {
10094 if ( $.fx.step[ name ] || !isNaN( parseFloat( value ) ) ) {
10095 diff[ name ] = value;
10096 }
10097 }
10098 }
10099 }
10100
10101 return diff;
10102 }
10103
10104 // support: jQuery <1.8
10105 if ( !$.fn.addBack ) {
10106 $.fn.addBack = function( selector ) {
10107 return this.add( selector == null ?
10108 this.prevObject : this.prevObject.filter( selector )
10109 );
10110 };
10111 }
10112
10113 $.effects.animateClass = function( value, duration, easing, callback ) {
10114 var o = $.speed( duration, easing, callback );
10115
10116 return this.queue( function() {
10117 var animated = $( this ),
10118 baseClass = animated.attr( "class" ) || "",
10119 applyClassChange,
10120 allAnimations = o.children ? animated.find( "*" ).addBack() : animated;
10121
10122 // map the animated objects to store the original styles.
10123 allAnimations = allAnimations.map(function() {
10124 var el = $( this );
10125 return {
10126 el: el,
10127 start: getElementStyles( this )
10128 };
10129 });
10130
10131 // apply class change
10132 applyClassChange = function() {
10133 $.each( classAnimationActions, function(i, action) {
10134 if ( value[ action ] ) {
10135 animated[ action + "Class" ]( value[ action ] );
10136 }
10137 });
10138 };
10139 applyClassChange();
10140
10141 // map all animated objects again - calculate new styles and diff
10142 allAnimations = allAnimations.map(function() {
10143 this.end = getElementStyles( this.el[ 0 ] );
10144 this.diff = styleDifference( this.start, this.end );
10145 return this;
10146 });
10147
10148 // apply original class
10149 animated.attr( "class", baseClass );
10150
10151 // map all animated objects again - this time collecting a promise
10152 allAnimations = allAnimations.map(function() {
10153 var styleInfo = this,
10154 dfd = $.Deferred(),
10155 opts = $.extend({}, o, {
10156 queue: false,
10157 complete: function() {
10158 dfd.resolve( styleInfo );
10159 }
10160 });
10161
10162 this.el.animate( this.diff, opts );
10163 return dfd.promise();
10164 });
10165
10166 // once all animations have completed:
10167 $.when.apply( $, allAnimations.get() ).done(function() {
10168
10169 // set the final class
10170 applyClassChange();
10171
10172 // for each animated element,
10173 // clear all css properties that were animated
10174 $.each( arguments, function() {
10175 var el = this.el;
10176 $.each( this.diff, function(key) {
10177 el.css( key, "" );
10178 });
10179 });
10180
10181 // this is guarnteed to be there if you use jQuery.speed()
10182 // it also handles dequeuing the next anim...
10183 o.complete.call( animated[ 0 ] );
10184 });
10185 });
10186 };
10187
10188 $.fn.extend({
10189 addClass: (function( orig ) {
10190 return function( classNames, speed, easing, callback ) {
10191 return speed ?
10192 $.effects.animateClass.call( this,
10193 { add: classNames }, speed, easing, callback ) :
10194 orig.apply( this, arguments );
10195 };
10196 })( $.fn.addClass ),
10197
10198 removeClass: (function( orig ) {
10199 return function( classNames, speed, easing, callback ) {
10200 return arguments.length > 1 ?
10201 $.effects.animateClass.call( this,
10202 { remove: classNames }, speed, easing, callback ) :
10203 orig.apply( this, arguments );
10204 };
10205 })( $.fn.removeClass ),
10206
10207 toggleClass: (function( orig ) {
10208 return function( classNames, force, speed, easing, callback ) {
10209 if ( typeof force === "boolean" || force === undefined ) {
10210 if ( !speed ) {
10211 // without speed parameter
10212 return orig.apply( this, arguments );
10213 } else {
10214 return $.effects.animateClass.call( this,
10215 (force ? { add: classNames } : { remove: classNames }),
10216 speed, easing, callback );
10217 }
10218 } else {
10219 // without force parameter
10220 return $.effects.animateClass.call( this,
10221 { toggle: classNames }, force, speed, easing );
10222 }
10223 };
10224 })( $.fn.toggleClass ),
10225
10226 switchClass: function( remove, add, speed, easing, callback) {
10227 return $.effects.animateClass.call( this, {
10228 add: add,
10229 remove: remove
10230 }, speed, easing, callback );
10231 }
10232 });
10233
10234 })();
10235
10236 /******************************************************************************/
10237 /*********************************** EFFECTS **********************************/
10238 /******************************************************************************/
10239
10240 (function() {
10241
10242 $.extend( $.effects, {
10243 version: "1.11.4",
10244
10245 // Saves a set of properties in a data storage
10246 save: function( element, set ) {
10247 for ( var i = 0; i < set.length; i++ ) {
10248 if ( set[ i ] !== null ) {
10249 element.data( dataSpace + set[ i ], element[ 0 ].style[ set[ i ] ] );
10250 }
10251 }
10252 },
10253
10254 // Restores a set of previously saved properties from a data storage
10255 restore: function( element, set ) {
10256 var val, i;
10257 for ( i = 0; i < set.length; i++ ) {
10258 if ( set[ i ] !== null ) {
10259 val = element.data( dataSpace + set[ i ] );
10260 // support: jQuery 1.6.2
10261 // http://bugs.jquery.com/ticket/9917
10262 // jQuery 1.6.2 incorrectly returns undefined for any falsy value.
10263 // We can't differentiate between "" and 0 here, so we just assume
10264 // empty string since it's likely to be a more common value...
10265 if ( val === undefined ) {
10266 val = "";
10267 }
10268 element.css( set[ i ], val );
10269 }
10270 }
10271 },
10272
10273 setMode: function( el, mode ) {
10274 if (mode === "toggle") {
10275 mode = el.is( ":hidden" ) ? "show" : "hide";
10276 }
10277 return mode;
10278 },
10279
10280 // Translates a [top,left] array into a baseline value
10281 // this should be a little more flexible in the future to handle a string & hash
10282 getBaseline: function( origin, original ) {
10283 var y, x;
10284 switch ( origin[ 0 ] ) {
10285 case "top": y = 0; break;
10286 case "middle": y = 0.5; break;
10287 case "bottom": y = 1; break;
10288 default: y = origin[ 0 ] / original.height;
10289 }
10290 switch ( origin[ 1 ] ) {
10291 case "left": x = 0; break;
10292 case "center": x = 0.5; break;
10293 case "right": x = 1; break;
10294 default: x = origin[ 1 ] / original.width;
10295 }
10296 return {
10297 x: x,
10298 y: y
10299 };
10300 },
10301
10302 // Wraps the element around a wrapper that copies position properties
10303 createWrapper: function( element ) {
10304
10305 // if the element is already wrapped, return it
10306 if ( element.parent().is( ".ui-effects-wrapper" )) {
10307 return element.parent();
10308 }
10309
10310 // wrap the element
10311 var props = {
10312 width: element.outerWidth(true),
10313 height: element.outerHeight(true),
10314 "float": element.css( "float" )
10315 },
10316 wrapper = $( "<div></div>" )
10317 .addClass( "ui-effects-wrapper" )
10318 .css({
10319 fontSize: "100%",
10320 background: "transparent",
10321 border: "none",
10322 margin: 0,
10323 padding: 0
10324 }),
10325 // Store the size in case width/height are defined in % - Fixes #5245
10326 size = {
10327 width: element.width(),
10328 height: element.height()
10329 },
10330 active = document.activeElement;
10331
10332 // support: Firefox
10333 // Firefox incorrectly exposes anonymous content
10334 // https://bugzilla.mozilla.org/show_bug.cgi?id=561664
10335 try {
10336 active.id;
10337 } catch ( e ) {
10338 active = document.body;
10339 }
10340
10341 element.wrap( wrapper );
10342
10343 // Fixes #7595 - Elements lose focus when wrapped.
10344 if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
10345 $( active ).focus();
10346 }
10347
10348 wrapper = element.parent(); //Hotfix for jQuery 1.4 since some change in wrap() seems to actually lose the reference to the wrapped element
10349
10350 // transfer positioning properties to the wrapper
10351 if ( element.css( "position" ) === "static" ) {
10352 wrapper.css({ position: "relative" });
10353 element.css({ position: "relative" });
10354 } else {
10355 $.extend( props, {
10356 position: element.css( "position" ),
10357 zIndex: element.css( "z-index" )
10358 });
10359 $.each([ "top", "left", "bottom", "right" ], function(i, pos) {
10360 props[ pos ] = element.css( pos );
10361 if ( isNaN( parseInt( props[ pos ], 10 ) ) ) {
10362 props[ pos ] = "auto";
10363 }
10364 });
10365 element.css({
10366 position: "relative",
10367 top: 0,
10368 left: 0,
10369 right: "auto",
10370 bottom: "auto"
10371 });
10372 }
10373 element.css(size);
10374
10375 return wrapper.css( props ).show();
10376 },
10377
10378 removeWrapper: function( element ) {
10379 var active = document.activeElement;
10380
10381 if ( element.parent().is( ".ui-effects-wrapper" ) ) {
10382 element.parent().replaceWith( element );
10383
10384 // Fixes #7595 - Elements lose focus when wrapped.
10385 if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
10386 $( active ).focus();
10387 }
10388 }
10389
10390 return element;
10391 },
10392
10393 setTransition: function( element, list, factor, value ) {
10394 value = value || {};
10395 $.each( list, function( i, x ) {
10396 var unit = element.cssUnit( x );
10397 if ( unit[ 0 ] > 0 ) {
10398 value[ x ] = unit[ 0 ] * factor + unit[ 1 ];
10399 }
10400 });
10401 return value;
10402 }
10403 });
10404
10405 // return an effect options object for the given parameters:
10406 function _normalizeArguments( effect, options, speed, callback ) {
10407
10408 // allow passing all options as the first parameter
10409 if ( $.isPlainObject( effect ) ) {
10410 options = effect;
10411 effect = effect.effect;
10412 }
10413
10414 // convert to an object
10415 effect = { effect: effect };
10416
10417 // catch (effect, null, ...)
10418 if ( options == null ) {
10419 options = {};
10420 }
10421
10422 // catch (effect, callback)
10423 if ( $.isFunction( options ) ) {
10424 callback = options;
10425 speed = null;
10426 options = {};
10427 }
10428
10429 // catch (effect, speed, ?)
10430 if ( typeof options === "number" || $.fx.speeds[ options ] ) {
10431 callback = speed;
10432 speed = options;
10433 options = {};
10434 }
10435
10436 // catch (effect, options, callback)
10437 if ( $.isFunction( speed ) ) {
10438 callback = speed;
10439 speed = null;
10440 }
10441
10442 // add options to effect
10443 if ( options ) {
10444 $.extend( effect, options );
10445 }
10446
10447 speed = speed || options.duration;
10448 effect.duration = $.fx.off ? 0 :
10449 typeof speed === "number" ? speed :
10450 speed in $.fx.speeds ? $.fx.speeds[ speed ] :
10451 $.fx.speeds._default;
10452
10453 effect.complete = callback || options.complete;
10454
10455 return effect;
10456 }
10457
10458 function standardAnimationOption( option ) {
10459 // Valid standard speeds (nothing, number, named speed)
10460 if ( !option || typeof option === "number" || $.fx.speeds[ option ] ) {
10461 return true;
10462 }
10463
10464 // Invalid strings - treat as "normal" speed
10465 if ( typeof option === "string" && !$.effects.effect[ option ] ) {
10466 return true;
10467 }
10468
10469 // Complete callback
10470 if ( $.isFunction( option ) ) {
10471 return true;
10472 }
10473
10474 // Options hash (but not naming an effect)
10475 if ( typeof option === "object" && !option.effect ) {
10476 return true;
10477 }
10478
10479 // Didn't match any standard API
10480 return false;
10481 }
10482
10483 $.fn.extend({
10484 effect: function( /* effect, options, speed, callback */ ) {
10485 var args = _normalizeArguments.apply( this, arguments ),
10486 mode = args.mode,
10487 queue = args.queue,
10488 effectMethod = $.effects.effect[ args.effect ];
10489
10490 if ( $.fx.off || !effectMethod ) {
10491 // delegate to the original method (e.g., .show()) if possible
10492 if ( mode ) {
10493 return this[ mode ]( args.duration, args.complete );
10494 } else {
10495 return this.each( function() {
10496 if ( args.complete ) {
10497 args.complete.call( this );
10498 }
10499 });
10500 }
10501 }
10502
10503 function run( next ) {
10504 var elem = $( this ),
10505 complete = args.complete,
10506 mode = args.mode;
10507
10508 function done() {
10509 if ( $.isFunction( complete ) ) {
10510 complete.call( elem[0] );
10511 }
10512 if ( $.isFunction( next ) ) {
10513 next();
10514 }
10515 }
10516
10517 // If the element already has the correct final state, delegate to
10518 // the core methods so the internal tracking of "olddisplay" works.
10519 if ( elem.is( ":hidden" ) ? mode === "hide" : mode === "show" ) {
10520 elem[ mode ]();
10521 done();
10522 } else {
10523 effectMethod.call( elem[0], args, done );
10524 }
10525 }
10526
10527 return queue === false ? this.each( run ) : this.queue( queue || "fx", run );
10528 },
10529
10530 show: (function( orig ) {
10531 return function( option ) {
10532 if ( standardAnimationOption( option ) ) {
10533 return orig.apply( this, arguments );
10534 } else {
10535 var args = _normalizeArguments.apply( this, arguments );
10536 args.mode = "show";
10537 return this.effect.call( this, args );
10538 }
10539 };
10540 })( $.fn.show ),
10541
10542 hide: (function( orig ) {
10543 return function( option ) {
10544 if ( standardAnimationOption( option ) ) {
10545 return orig.apply( this, arguments );
10546 } else {
10547 var args = _normalizeArguments.apply( this, arguments );
10548 args.mode = "hide";
10549 return this.effect.call( this, args );
10550 }
10551 };
10552 })( $.fn.hide ),
10553
10554 toggle: (function( orig ) {
10555 return function( option ) {
10556 if ( standardAnimationOption( option ) || typeof option === "boolean" ) {
10557 return orig.apply( this, arguments );
10558 } else {
10559 var args = _normalizeArguments.apply( this, arguments );
10560 args.mode = "toggle";
10561 return this.effect.call( this, args );
10562 }
10563 };
10564 })( $.fn.toggle ),
10565
10566 // helper functions
10567 cssUnit: function(key) {
10568 var style = this.css( key ),
10569 val = [];
10570
10571 $.each( [ "em", "px", "%", "pt" ], function( i, unit ) {
10572 if ( style.indexOf( unit ) > 0 ) {
10573 val = [ parseFloat( style ), unit ];
10574 }
10575 });
10576 return val;
10577 }
10578 });
10579
10580 })();
10581
10582 /******************************************************************************/
10583 /*********************************** EASING ***********************************/
10584 /******************************************************************************/
10585
10586 (function() {
10587
10588 // based on easing equations from Robert Penner (http://www.robertpenner.com/easing)
10589
10590 var baseEasings = {};
10591
10592 $.each( [ "Quad", "Cubic", "Quart", "Quint", "Expo" ], function( i, name ) {
10593 baseEasings[ name ] = function( p ) {
10594 return Math.pow( p, i + 2 );
10595 };
10596 });
10597
10598 $.extend( baseEasings, {
10599 Sine: function( p ) {
10600 return 1 - Math.cos( p * Math.PI / 2 );
10601 },
10602 Circ: function( p ) {
10603 return 1 - Math.sqrt( 1 - p * p );
10604 },
10605 Elastic: function( p ) {
10606 return p === 0 || p === 1 ? p :
10607 -Math.pow( 2, 8 * (p - 1) ) * Math.sin( ( (p - 1) * 80 - 7.5 ) * Math.PI / 15 );
10608 },
10609 Back: function( p ) {
10610 return p * p * ( 3 * p - 2 );
10611 },
10612 Bounce: function( p ) {
10613 var pow2,
10614 bounce = 4;
10615
10616 while ( p < ( ( pow2 = Math.pow( 2, --bounce ) ) - 1 ) / 11 ) {}
10617 return 1 / Math.pow( 4, 3 - bounce ) - 7.5625 * Math.pow( ( pow2 * 3 - 2 ) / 22 - p, 2 );
10618 }
10619 });
10620
10621 $.each( baseEasings, function( name, easeIn ) {
10622 $.easing[ "easeIn" + name ] = easeIn;
10623 $.easing[ "easeOut" + name ] = function( p ) {
10624 return 1 - easeIn( 1 - p );
10625 };
10626 $.easing[ "easeInOut" + name ] = function( p ) {
10627 return p < 0.5 ?
10628 easeIn( p * 2 ) / 2 :
10629 1 - easeIn( p * -2 + 2 ) / 2;
10630 };
10631 });
10632
10633 })();
10634
10635 var effect = $.effects;
10636
10637
10638 /*!
10639 * jQuery UI Effects Blind 1.11.4
10640 * http://jqueryui.com
10641 *
10642 * Copyright jQuery Foundation and other contributors
10643 * Released under the MIT license.
10644 * http://jquery.org/license
10645 *
10646 * http://api.jqueryui.com/blind-effect/
10647 */
10648
10649
10650 var effectBlind = $.effects.effect.blind = function( o, done ) {
10651 // Create element
10652 var el = $( this ),
10653 rvertical = /up|down|vertical/,
10654 rpositivemotion = /up|left|vertical|horizontal/,
10655 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
10656 mode = $.effects.setMode( el, o.mode || "hide" ),
10657 direction = o.direction || "up",
10658 vertical = rvertical.test( direction ),
10659 ref = vertical ? "height" : "width",
10660 ref2 = vertical ? "top" : "left",
10661 motion = rpositivemotion.test( direction ),
10662 animation = {},
10663 show = mode === "show",
10664 wrapper, distance, margin;
10665
10666 // if already wrapped, the wrapper's properties are my property. #6245
10667 if ( el.parent().is( ".ui-effects-wrapper" ) ) {
10668 $.effects.save( el.parent(), props );
10669 } else {
10670 $.effects.save( el, props );
10671 }
10672 el.show();
10673 wrapper = $.effects.createWrapper( el ).css({
10674 overflow: "hidden"
10675 });
10676
10677 distance = wrapper[ ref ]();
10678 margin = parseFloat( wrapper.css( ref2 ) ) || 0;
10679
10680 animation[ ref ] = show ? distance : 0;
10681 if ( !motion ) {
10682 el
10683 .css( vertical ? "bottom" : "right", 0 )
10684 .css( vertical ? "top" : "left", "auto" )
10685 .css({ position: "absolute" });
10686
10687 animation[ ref2 ] = show ? margin : distance + margin;
10688 }
10689
10690 // start at 0 if we are showing
10691 if ( show ) {
10692 wrapper.css( ref, 0 );
10693 if ( !motion ) {
10694 wrapper.css( ref2, margin + distance );
10695 }
10696 }
10697
10698 // Animate
10699 wrapper.animate( animation, {
10700 duration: o.duration,
10701 easing: o.easing,
10702 queue: false,
10703 complete: function() {
10704 if ( mode === "hide" ) {
10705 el.hide();
10706 }
10707 $.effects.restore( el, props );
10708 $.effects.removeWrapper( el );
10709 done();
10710 }
10711 });
10712 };
10713
10714
10715 /*!
10716 * jQuery UI Effects Bounce 1.11.4
10717 * http://jqueryui.com
10718 *
10719 * Copyright jQuery Foundation and other contributors
10720 * Released under the MIT license.
10721 * http://jquery.org/license
10722 *
10723 * http://api.jqueryui.com/bounce-effect/
10724 */
10725
10726
10727 var effectBounce = $.effects.effect.bounce = function( o, done ) {
10728 var el = $( this ),
10729 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
10730
10731 // defaults:
10732 mode = $.effects.setMode( el, o.mode || "effect" ),
10733 hide = mode === "hide",
10734 show = mode === "show",
10735 direction = o.direction || "up",
10736 distance = o.distance,
10737 times = o.times || 5,
10738
10739 // number of internal animations
10740 anims = times * 2 + ( show || hide ? 1 : 0 ),
10741 speed = o.duration / anims,
10742 easing = o.easing,
10743
10744 // utility:
10745 ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
10746 motion = ( direction === "up" || direction === "left" ),
10747 i,
10748 upAnim,
10749 downAnim,
10750
10751 // we will need to re-assemble the queue to stack our animations in place
10752 queue = el.queue(),
10753 queuelen = queue.length;
10754
10755 // Avoid touching opacity to prevent clearType and PNG issues in IE
10756 if ( show || hide ) {
10757 props.push( "opacity" );
10758 }
10759
10760 $.effects.save( el, props );
10761 el.show();
10762 $.effects.createWrapper( el ); // Create Wrapper
10763
10764 // default distance for the BIGGEST bounce is the outer Distance / 3
10765 if ( !distance ) {
10766 distance = el[ ref === "top" ? "outerHeight" : "outerWidth" ]() / 3;
10767 }
10768
10769 if ( show ) {
10770 downAnim = { opacity: 1 };
10771 downAnim[ ref ] = 0;
10772
10773 // if we are showing, force opacity 0 and set the initial position
10774 // then do the "first" animation
10775 el.css( "opacity", 0 )
10776 .css( ref, motion ? -distance * 2 : distance * 2 )
10777 .animate( downAnim, speed, easing );
10778 }
10779
10780 // start at the smallest distance if we are hiding
10781 if ( hide ) {
10782 distance = distance / Math.pow( 2, times - 1 );
10783 }
10784
10785 downAnim = {};
10786 downAnim[ ref ] = 0;
10787 // Bounces up/down/left/right then back to 0 -- times * 2 animations happen here
10788 for ( i = 0; i < times; i++ ) {
10789 upAnim = {};
10790 upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance;
10791
10792 el.animate( upAnim, speed, easing )
10793 .animate( downAnim, speed, easing );
10794
10795 distance = hide ? distance * 2 : distance / 2;
10796 }
10797
10798 // Last Bounce when Hiding
10799 if ( hide ) {
10800 upAnim = { opacity: 0 };
10801 upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance;
10802
10803 el.animate( upAnim, speed, easing );
10804 }
10805
10806 el.queue(function() {
10807 if ( hide ) {
10808 el.hide();
10809 }
10810 $.effects.restore( el, props );
10811 $.effects.removeWrapper( el );
10812 done();
10813 });
10814
10815 // inject all the animations we just queued to be first in line (after "inprogress")
10816 if ( queuelen > 1) {
10817 queue.splice.apply( queue,
10818 [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
10819 }
10820 el.dequeue();
10821
10822 };
10823
10824
10825 /*!
10826 * jQuery UI Effects Clip 1.11.4
10827 * http://jqueryui.com
10828 *
10829 * Copyright jQuery Foundation and other contributors
10830 * Released under the MIT license.
10831 * http://jquery.org/license
10832 *
10833 * http://api.jqueryui.com/clip-effect/
10834 */
10835
10836
10837 var effectClip = $.effects.effect.clip = function( o, done ) {
10838 // Create element
10839 var el = $( this ),
10840 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
10841 mode = $.effects.setMode( el, o.mode || "hide" ),
10842 show = mode === "show",
10843 direction = o.direction || "vertical",
10844 vert = direction === "vertical",
10845 size = vert ? "height" : "width",
10846 position = vert ? "top" : "left",
10847 animation = {},
10848 wrapper, animate, distance;
10849
10850 // Save & Show
10851 $.effects.save( el, props );
10852 el.show();
10853
10854 // Create Wrapper
10855 wrapper = $.effects.createWrapper( el ).css({
10856 overflow: "hidden"
10857 });
10858 animate = ( el[0].tagName === "IMG" ) ? wrapper : el;
10859 distance = animate[ size ]();
10860
10861 // Shift
10862 if ( show ) {
10863 animate.css( size, 0 );
10864 animate.css( position, distance / 2 );
10865 }
10866
10867 // Create Animation Object:
10868 animation[ size ] = show ? distance : 0;
10869 animation[ position ] = show ? 0 : distance / 2;
10870
10871 // Animate
10872 animate.animate( animation, {
10873 queue: false,
10874 duration: o.duration,
10875 easing: o.easing,
10876 complete: function() {
10877 if ( !show ) {
10878 el.hide();
10879 }
10880 $.effects.restore( el, props );
10881 $.effects.removeWrapper( el );
10882 done();
10883 }
10884 });
10885
10886 };
10887
10888
10889 /*!
10890 * jQuery UI Effects Drop 1.11.4
10891 * http://jqueryui.com
10892 *
10893 * Copyright jQuery Foundation and other contributors
10894 * Released under the MIT license.
10895 * http://jquery.org/license
10896 *
10897 * http://api.jqueryui.com/drop-effect/
10898 */
10899
10900
10901 var effectDrop = $.effects.effect.drop = function( o, done ) {
10902
10903 var el = $( this ),
10904 props = [ "position", "top", "bottom", "left", "right", "opacity", "height", "width" ],
10905 mode = $.effects.setMode( el, o.mode || "hide" ),
10906 show = mode === "show",
10907 direction = o.direction || "left",
10908 ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
10909 motion = ( direction === "up" || direction === "left" ) ? "pos" : "neg",
10910 animation = {
10911 opacity: show ? 1 : 0
10912 },
10913 distance;
10914
10915 // Adjust
10916 $.effects.save( el, props );
10917 el.show();
10918 $.effects.createWrapper( el );
10919
10920 distance = o.distance || el[ ref === "top" ? "outerHeight" : "outerWidth" ]( true ) / 2;
10921
10922 if ( show ) {
10923 el
10924 .css( "opacity", 0 )
10925 .css( ref, motion === "pos" ? -distance : distance );
10926 }
10927
10928 // Animation
10929 animation[ ref ] = ( show ?
10930 ( motion === "pos" ? "+=" : "-=" ) :
10931 ( motion === "pos" ? "-=" : "+=" ) ) +
10932 distance;
10933
10934 // Animate
10935 el.animate( animation, {
10936 queue: false,
10937 duration: o.duration,
10938 easing: o.easing,
10939 complete: function() {
10940 if ( mode === "hide" ) {
10941 el.hide();
10942 }
10943 $.effects.restore( el, props );
10944 $.effects.removeWrapper( el );
10945 done();
10946 }
10947 });
10948 };
10949
10950
10951 /*!
10952 * jQuery UI Effects Explode 1.11.4
10953 * http://jqueryui.com
10954 *
10955 * Copyright jQuery Foundation and other contributors
10956 * Released under the MIT license.
10957 * http://jquery.org/license
10958 *
10959 * http://api.jqueryui.com/explode-effect/
10960 */
10961
10962
10963 var effectExplode = $.effects.effect.explode = function( o, done ) {
10964
10965 var rows = o.pieces ? Math.round( Math.sqrt( o.pieces ) ) : 3,
10966 cells = rows,
10967 el = $( this ),
10968 mode = $.effects.setMode( el, o.mode || "hide" ),
10969 show = mode === "show",
10970
10971 // show and then visibility:hidden the element before calculating offset
10972 offset = el.show().css( "visibility", "hidden" ).offset(),
10973
10974 // width and height of a piece
10975 width = Math.ceil( el.outerWidth() / cells ),
10976 height = Math.ceil( el.outerHeight() / rows ),
10977 pieces = [],
10978
10979 // loop
10980 i, j, left, top, mx, my;
10981
10982 // children animate complete:
10983 function childComplete() {
10984 pieces.push( this );
10985 if ( pieces.length === rows * cells ) {
10986 animComplete();
10987 }
10988 }
10989
10990 // clone the element for each row and cell.
10991 for ( i = 0; i < rows ; i++ ) { // ===>
10992 top = offset.top + i * height;
10993 my = i - ( rows - 1 ) / 2 ;
10994
10995 for ( j = 0; j < cells ; j++ ) { // |||
10996 left = offset.left + j * width;
10997 mx = j - ( cells - 1 ) / 2 ;
10998
10999 // Create a clone of the now hidden main element that will be absolute positioned
11000 // within a wrapper div off the -left and -top equal to size of our pieces
11001 el
11002 .clone()
11003 .appendTo( "body" )
11004 .wrap( "<div></div>" )
11005 .css({
11006 position: "absolute",
11007 visibility: "visible",
11008 left: -j * width,
11009 top: -i * height
11010 })
11011
11012 // select the wrapper - make it overflow: hidden and absolute positioned based on
11013 // where the original was located +left and +top equal to the size of pieces
11014 .parent()
11015 .addClass( "ui-effects-explode" )
11016 .css({
11017 position: "absolute",
11018 overflow: "hidden",
11019 width: width,
11020 height: height,
11021 left: left + ( show ? mx * width : 0 ),
11022 top: top + ( show ? my * height : 0 ),
11023 opacity: show ? 0 : 1
11024 }).animate({
11025 left: left + ( show ? 0 : mx * width ),
11026 top: top + ( show ? 0 : my * height ),
11027 opacity: show ? 1 : 0
11028 }, o.duration || 500, o.easing, childComplete );
11029 }
11030 }
11031
11032 function animComplete() {
11033 el.css({
11034 visibility: "visible"
11035 });
11036 $( pieces ).remove();
11037 if ( !show ) {
11038 el.hide();
11039 }
11040 done();
11041 }
11042 };
11043
11044
11045 /*!
11046 * jQuery UI Effects Fade 1.11.4
11047 * http://jqueryui.com
11048 *
11049 * Copyright jQuery Foundation and other contributors
11050 * Released under the MIT license.
11051 * http://jquery.org/license
11052 *
11053 * http://api.jqueryui.com/fade-effect/
11054 */
11055
11056
11057 var effectFade = $.effects.effect.fade = function( o, done ) {
11058 var el = $( this ),
11059 mode = $.effects.setMode( el, o.mode || "toggle" );
11060
11061 el.animate({
11062 opacity: mode
11063 }, {
11064 queue: false,
11065 duration: o.duration,
11066 easing: o.easing,
11067 complete: done
11068 });
11069 };
11070
11071
11072 /*!
11073 * jQuery UI Effects Fold 1.11.4
11074 * http://jqueryui.com
11075 *
11076 * Copyright jQuery Foundation and other contributors
11077 * Released under the MIT license.
11078 * http://jquery.org/license
11079 *
11080 * http://api.jqueryui.com/fold-effect/
11081 */
11082
11083
11084 var effectFold = $.effects.effect.fold = function( o, done ) {
11085
11086 // Create element
11087 var el = $( this ),
11088 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
11089 mode = $.effects.setMode( el, o.mode || "hide" ),
11090 show = mode === "show",
11091 hide = mode === "hide",
11092 size = o.size || 15,
11093 percent = /([0-9]+)%/.exec( size ),
11094 horizFirst = !!o.horizFirst,
11095 widthFirst = show !== horizFirst,
11096 ref = widthFirst ? [ "width", "height" ] : [ "height", "width" ],
11097 duration = o.duration / 2,
11098 wrapper, distance,
11099 animation1 = {},
11100 animation2 = {};
11101
11102 $.effects.save( el, props );
11103 el.show();
11104
11105 // Create Wrapper
11106 wrapper = $.effects.createWrapper( el ).css({
11107 overflow: "hidden"
11108 });
11109 distance = widthFirst ?
11110 [ wrapper.width(), wrapper.height() ] :
11111 [ wrapper.height(), wrapper.width() ];
11112
11113 if ( percent ) {
11114 size = parseInt( percent[ 1 ], 10 ) / 100 * distance[ hide ? 0 : 1 ];
11115 }
11116 if ( show ) {
11117 wrapper.css( horizFirst ? {
11118 height: 0,
11119 width: size
11120 } : {
11121 height: size,
11122 width: 0
11123 });
11124 }
11125
11126 // Animation
11127 animation1[ ref[ 0 ] ] = show ? distance[ 0 ] : size;
11128 animation2[ ref[ 1 ] ] = show ? distance[ 1 ] : 0;
11129
11130 // Animate
11131 wrapper
11132 .animate( animation1, duration, o.easing )
11133 .animate( animation2, duration, o.easing, function() {
11134 if ( hide ) {
11135 el.hide();
11136 }
11137 $.effects.restore( el, props );
11138 $.effects.removeWrapper( el );
11139 done();
11140 });
11141
11142 };
11143
11144
11145 /*!
11146 * jQuery UI Effects Highlight 1.11.4
11147 * http://jqueryui.com
11148 *
11149 * Copyright jQuery Foundation and other contributors
11150 * Released under the MIT license.
11151 * http://jquery.org/license
11152 *
11153 * http://api.jqueryui.com/highlight-effect/
11154 */
11155
11156
11157 var effectHighlight = $.effects.effect.highlight = function( o, done ) {
11158 var elem = $( this ),
11159 props = [ "backgroundImage", "backgroundColor", "opacity" ],
11160 mode = $.effects.setMode( elem, o.mode || "show" ),
11161 animation = {
11162 backgroundColor: elem.css( "backgroundColor" )
11163 };
11164
11165 if (mode === "hide") {
11166 animation.opacity = 0;
11167 }
11168
11169 $.effects.save( elem, props );
11170
11171 elem
11172 .show()
11173 .css({
11174 backgroundImage: "none",
11175 backgroundColor: o.color || "#ffff99"
11176 })
11177 .animate( animation, {
11178 queue: false,
11179 duration: o.duration,
11180 easing: o.easing,
11181 complete: function() {
11182 if ( mode === "hide" ) {
11183 elem.hide();
11184 }
11185 $.effects.restore( elem, props );
11186 done();
11187 }
11188 });
11189 };
11190
11191
11192 /*!
11193 * jQuery UI Effects Size 1.11.4
11194 * http://jqueryui.com
11195 *
11196 * Copyright jQuery Foundation and other contributors
11197 * Released under the MIT license.
11198 * http://jquery.org/license
11199 *
11200 * http://api.jqueryui.com/size-effect/
11201 */
11202
11203
11204 var effectSize = $.effects.effect.size = function( o, done ) {
11205
11206 // Create element
11207 var original, baseline, factor,
11208 el = $( this ),
11209 props0 = [ "position", "top", "bottom", "left", "right", "width", "height", "overflow", "opacity" ],
11210
11211 // Always restore
11212 props1 = [ "position", "top", "bottom", "left", "right", "overflow", "opacity" ],
11213
11214 // Copy for children
11215 props2 = [ "width", "height", "overflow" ],
11216 cProps = [ "fontSize" ],
11217 vProps = [ "borderTopWidth", "borderBottomWidth", "paddingTop", "paddingBottom" ],
11218 hProps = [ "borderLeftWidth", "borderRightWidth", "paddingLeft", "paddingRight" ],
11219
11220 // Set options
11221 mode = $.effects.setMode( el, o.mode || "effect" ),
11222 restore = o.restore || mode !== "effect",
11223 scale = o.scale || "both",
11224 origin = o.origin || [ "middle", "center" ],
11225 position = el.css( "position" ),
11226 props = restore ? props0 : props1,
11227 zero = {
11228 height: 0,
11229 width: 0,
11230 outerHeight: 0,
11231 outerWidth: 0
11232 };
11233
11234 if ( mode === "show" ) {
11235 el.show();
11236 }
11237 original = {
11238 height: el.height(),
11239 width: el.width(),
11240 outerHeight: el.outerHeight(),
11241 outerWidth: el.outerWidth()
11242 };
11243
11244 if ( o.mode === "toggle" && mode === "show" ) {
11245 el.from = o.to || zero;
11246 el.to = o.from || original;
11247 } else {
11248 el.from = o.from || ( mode === "show" ? zero : original );
11249 el.to = o.to || ( mode === "hide" ? zero : original );
11250 }
11251
11252 // Set scaling factor
11253 factor = {
11254 from: {
11255 y: el.from.height / original.height,
11256 x: el.from.width / original.width
11257 },
11258 to: {
11259 y: el.to.height / original.height,
11260 x: el.to.width / original.width
11261 }
11262 };
11263
11264 // Scale the css box
11265 if ( scale === "box" || scale === "both" ) {
11266
11267 // Vertical props scaling
11268 if ( factor.from.y !== factor.to.y ) {
11269 props = props.concat( vProps );
11270 el.from = $.effects.setTransition( el, vProps, factor.from.y, el.from );
11271 el.to = $.effects.setTransition( el, vProps, factor.to.y, el.to );
11272 }
11273
11274 // Horizontal props scaling
11275 if ( factor.from.x !== factor.to.x ) {
11276 props = props.concat( hProps );
11277 el.from = $.effects.setTransition( el, hProps, factor.from.x, el.from );
11278 el.to = $.effects.setTransition( el, hProps, factor.to.x, el.to );
11279 }
11280 }
11281
11282 // Scale the content
11283 if ( scale === "content" || scale === "both" ) {
11284
11285 // Vertical props scaling
11286 if ( factor.from.y !== factor.to.y ) {
11287 props = props.concat( cProps ).concat( props2 );
11288 el.from = $.effects.setTransition( el, cProps, factor.from.y, el.from );
11289 el.to = $.effects.setTransition( el, cProps, factor.to.y, el.to );
11290 }
11291 }
11292
11293 $.effects.save( el, props );
11294 el.show();
11295 $.effects.createWrapper( el );
11296 el.css( "overflow", "hidden" ).css( el.from );
11297
11298 // Adjust
11299 if (origin) { // Calculate baseline shifts
11300 baseline = $.effects.getBaseline( origin, original );
11301 el.from.top = ( original.outerHeight - el.outerHeight() ) * baseline.y;
11302 el.from.left = ( original.outerWidth - el.outerWidth() ) * baseline.x;
11303 el.to.top = ( original.outerHeight - el.to.outerHeight ) * baseline.y;
11304 el.to.left = ( original.outerWidth - el.to.outerWidth ) * baseline.x;
11305 }
11306 el.css( el.from ); // set top & left
11307
11308 // Animate
11309 if ( scale === "content" || scale === "both" ) { // Scale the children
11310
11311 // Add margins/font-size
11312 vProps = vProps.concat([ "marginTop", "marginBottom" ]).concat(cProps);
11313 hProps = hProps.concat([ "marginLeft", "marginRight" ]);
11314 props2 = props0.concat(vProps).concat(hProps);
11315
11316 el.find( "*[width]" ).each( function() {
11317 var child = $( this ),
11318 c_original = {
11319 height: child.height(),
11320 width: child.width(),
11321 outerHeight: child.outerHeight(),
11322 outerWidth: child.outerWidth()
11323 };
11324 if (restore) {
11325 $.effects.save(child, props2);
11326 }
11327
11328 child.from = {
11329 height: c_original.height * factor.from.y,
11330 width: c_original.width * factor.from.x,
11331 outerHeight: c_original.outerHeight * factor.from.y,
11332 outerWidth: c_original.outerWidth * factor.from.x
11333 };
11334 child.to = {
11335 height: c_original.height * factor.to.y,
11336 width: c_original.width * factor.to.x,
11337 outerHeight: c_original.height * factor.to.y,
11338 outerWidth: c_original.width * factor.to.x
11339 };
11340
11341 // Vertical props scaling
11342 if ( factor.from.y !== factor.to.y ) {
11343 child.from = $.effects.setTransition( child, vProps, factor.from.y, child.from );
11344 child.to = $.effects.setTransition( child, vProps, factor.to.y, child.to );
11345 }
11346
11347 // Horizontal props scaling
11348 if ( factor.from.x !== factor.to.x ) {
11349 child.from = $.effects.setTransition( child, hProps, factor.from.x, child.from );
11350 child.to = $.effects.setTransition( child, hProps, factor.to.x, child.to );
11351 }
11352
11353 // Animate children
11354 child.css( child.from );
11355 child.animate( child.to, o.duration, o.easing, function() {
11356
11357 // Restore children
11358 if ( restore ) {
11359 $.effects.restore( child, props2 );
11360 }
11361 });
11362 });
11363 }
11364
11365 // Animate
11366 el.animate( el.to, {
11367 queue: false,
11368 duration: o.duration,
11369 easing: o.easing,
11370 complete: function() {
11371 if ( el.to.opacity === 0 ) {
11372 el.css( "opacity", el.from.opacity );
11373 }
11374 if ( mode === "hide" ) {
11375 el.hide();
11376 }
11377 $.effects.restore( el, props );
11378 if ( !restore ) {
11379
11380 // we need to calculate our new positioning based on the scaling
11381 if ( position === "static" ) {
11382 el.css({
11383 position: "relative",
11384 top: el.to.top,
11385 left: el.to.left
11386 });
11387 } else {
11388 $.each([ "top", "left" ], function( idx, pos ) {
11389 el.css( pos, function( _, str ) {
11390 var val = parseInt( str, 10 ),
11391 toRef = idx ? el.to.left : el.to.top;
11392
11393 // if original was "auto", recalculate the new value from wrapper
11394 if ( str === "auto" ) {
11395 return toRef + "px";
11396 }
11397
11398 return val + toRef + "px";
11399 });
11400 });
11401 }
11402 }
11403
11404 $.effects.removeWrapper( el );
11405 done();
11406 }
11407 });
11408
11409 };
11410
11411
11412 /*!
11413 * jQuery UI Effects Scale 1.11.4
11414 * http://jqueryui.com
11415 *
11416 * Copyright jQuery Foundation and other contributors
11417 * Released under the MIT license.
11418 * http://jquery.org/license
11419 *
11420 * http://api.jqueryui.com/scale-effect/
11421 */
11422
11423
11424 var effectScale = $.effects.effect.scale = function( o, done ) {
11425
11426 // Create element
11427 var el = $( this ),
11428 options = $.extend( true, {}, o ),
11429 mode = $.effects.setMode( el, o.mode || "effect" ),
11430 percent = parseInt( o.percent, 10 ) ||
11431 ( parseInt( o.percent, 10 ) === 0 ? 0 : ( mode === "hide" ? 0 : 100 ) ),
11432 direction = o.direction || "both",
11433 origin = o.origin,
11434 original = {
11435 height: el.height(),
11436 width: el.width(),
11437 outerHeight: el.outerHeight(),
11438 outerWidth: el.outerWidth()
11439 },
11440 factor = {
11441 y: direction !== "horizontal" ? (percent / 100) : 1,
11442 x: direction !== "vertical" ? (percent / 100) : 1
11443 };
11444
11445 // We are going to pass this effect to the size effect:
11446 options.effect = "size";
11447 options.queue = false;
11448 options.complete = done;
11449
11450 // Set default origin and restore for show/hide
11451 if ( mode !== "effect" ) {
11452 options.origin = origin || [ "middle", "center" ];
11453 options.restore = true;
11454 }
11455
11456 options.from = o.from || ( mode === "show" ? {
11457 height: 0,
11458 width: 0,
11459 outerHeight: 0,
11460 outerWidth: 0
11461 } : original );
11462 options.to = {
11463 height: original.height * factor.y,
11464 width: original.width * factor.x,
11465 outerHeight: original.outerHeight * factor.y,
11466 outerWidth: original.outerWidth * factor.x
11467 };
11468
11469 // Fade option to support puff
11470 if ( options.fade ) {
11471 if ( mode === "show" ) {
11472 options.from.opacity = 0;
11473 options.to.opacity = 1;
11474 }
11475 if ( mode === "hide" ) {
11476 options.from.opacity = 1;
11477 options.to.opacity = 0;
11478 }
11479 }
11480
11481 // Animate
11482 el.effect( options );
11483
11484 };
11485
11486
11487 /*!
11488 * jQuery UI Effects Puff 1.11.4
11489 * http://jqueryui.com
11490 *
11491 * Copyright jQuery Foundation and other contributors
11492 * Released under the MIT license.
11493 * http://jquery.org/license
11494 *
11495 * http://api.jqueryui.com/puff-effect/
11496 */
11497
11498
11499 var effectPuff = $.effects.effect.puff = function( o, done ) {
11500 var elem = $( this ),
11501 mode = $.effects.setMode( elem, o.mode || "hide" ),
11502 hide = mode === "hide",
11503 percent = parseInt( o.percent, 10 ) || 150,
11504 factor = percent / 100,
11505 original = {
11506 height: elem.height(),
11507 width: elem.width(),
11508 outerHeight: elem.outerHeight(),
11509 outerWidth: elem.outerWidth()
11510 };
11511
11512 $.extend( o, {
11513 effect: "scale",
11514 queue: false,
11515 fade: true,
11516 mode: mode,
11517 complete: done,
11518 percent: hide ? percent : 100,
11519 from: hide ?
11520 original :
11521 {
11522 height: original.height * factor,
11523 width: original.width * factor,
11524 outerHeight: original.outerHeight * factor,
11525 outerWidth: original.outerWidth * factor
11526 }
11527 });
11528
11529 elem.effect( o );
11530 };
11531
11532
11533 /*!
11534 * jQuery UI Effects Pulsate 1.11.4
11535 * http://jqueryui.com
11536 *
11537 * Copyright jQuery Foundation and other contributors
11538 * Released under the MIT license.
11539 * http://jquery.org/license
11540 *
11541 * http://api.jqueryui.com/pulsate-effect/
11542 */
11543
11544
11545 var effectPulsate = $.effects.effect.pulsate = function( o, done ) {
11546 var elem = $( this ),
11547 mode = $.effects.setMode( elem, o.mode || "show" ),
11548 show = mode === "show",
11549 hide = mode === "hide",
11550 showhide = ( show || mode === "hide" ),
11551
11552 // showing or hiding leaves of the "last" animation
11553 anims = ( ( o.times || 5 ) * 2 ) + ( showhide ? 1 : 0 ),
11554 duration = o.duration / anims,
11555 animateTo = 0,
11556 queue = elem.queue(),
11557 queuelen = queue.length,
11558 i;
11559
11560 if ( show || !elem.is(":visible")) {
11561 elem.css( "opacity", 0 ).show();
11562 animateTo = 1;
11563 }
11564
11565 // anims - 1 opacity "toggles"
11566 for ( i = 1; i < anims; i++ ) {
11567 elem.animate({
11568 opacity: animateTo
11569 }, duration, o.easing );
11570 animateTo = 1 - animateTo;
11571 }
11572
11573 elem.animate({
11574 opacity: animateTo
11575 }, duration, o.easing);
11576
11577 elem.queue(function() {
11578 if ( hide ) {
11579 elem.hide();
11580 }
11581 done();
11582 });
11583
11584 // We just queued up "anims" animations, we need to put them next in the queue
11585 if ( queuelen > 1 ) {
11586 queue.splice.apply( queue,
11587 [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
11588 }
11589 elem.dequeue();
11590 };
11591
11592
11593 /*!
11594 * jQuery UI Effects Shake 1.11.4
11595 * http://jqueryui.com
11596 *
11597 * Copyright jQuery Foundation and other contributors
11598 * Released under the MIT license.
11599 * http://jquery.org/license
11600 *
11601 * http://api.jqueryui.com/shake-effect/
11602 */
11603
11604
11605 var effectShake = $.effects.effect.shake = function( o, done ) {
11606
11607 var el = $( this ),
11608 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
11609 mode = $.effects.setMode( el, o.mode || "effect" ),
11610 direction = o.direction || "left",
11611 distance = o.distance || 20,
11612 times = o.times || 3,
11613 anims = times * 2 + 1,
11614 speed = Math.round( o.duration / anims ),
11615 ref = (direction === "up" || direction === "down") ? "top" : "left",
11616 positiveMotion = (direction === "up" || direction === "left"),
11617 animation = {},
11618 animation1 = {},
11619 animation2 = {},
11620 i,
11621
11622 // we will need to re-assemble the queue to stack our animations in place
11623 queue = el.queue(),
11624 queuelen = queue.length;
11625
11626 $.effects.save( el, props );
11627 el.show();
11628 $.effects.createWrapper( el );
11629
11630 // Animation
11631 animation[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance;
11632 animation1[ ref ] = ( positiveMotion ? "+=" : "-=" ) + distance * 2;
11633 animation2[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance * 2;
11634
11635 // Animate
11636 el.animate( animation, speed, o.easing );
11637
11638 // Shakes
11639 for ( i = 1; i < times; i++ ) {
11640 el.animate( animation1, speed, o.easing ).animate( animation2, speed, o.easing );
11641 }
11642 el
11643 .animate( animation1, speed, o.easing )
11644 .animate( animation, speed / 2, o.easing )
11645 .queue(function() {
11646 if ( mode === "hide" ) {
11647 el.hide();
11648 }
11649 $.effects.restore( el, props );
11650 $.effects.removeWrapper( el );
11651 done();
11652 });
11653
11654 // inject all the animations we just queued to be first in line (after "inprogress")
11655 if ( queuelen > 1) {
11656 queue.splice.apply( queue,
11657 [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
11658 }
11659 el.dequeue();
11660
11661 };
11662
11663
11664 /*!
11665 * jQuery UI Effects Slide 1.11.4
11666 * http://jqueryui.com
11667 *
11668 * Copyright jQuery Foundation and other contributors
11669 * Released under the MIT license.
11670 * http://jquery.org/license
11671 *
11672 * http://api.jqueryui.com/slide-effect/
11673 */
11674
11675
11676 var effectSlide = $.effects.effect.slide = function( o, done ) {
11677
11678 // Create element
11679 var el = $( this ),
11680 props = [ "position", "top", "bottom", "left", "right", "width", "height" ],
11681 mode = $.effects.setMode( el, o.mode || "show" ),
11682 show = mode === "show",
11683 direction = o.direction || "left",
11684 ref = (direction === "up" || direction === "down") ? "top" : "left",
11685 positiveMotion = (direction === "up" || direction === "left"),
11686 distance,
11687 animation = {};
11688
11689 // Adjust
11690 $.effects.save( el, props );
11691 el.show();
11692 distance = o.distance || el[ ref === "top" ? "outerHeight" : "outerWidth" ]( true );
11693
11694 $.effects.createWrapper( el ).css({
11695 overflow: "hidden"
11696 });
11697
11698 if ( show ) {
11699 el.css( ref, positiveMotion ? (isNaN(distance) ? "-" + distance : -distance) : distance );
11700 }
11701
11702 // Animation
11703 animation[ ref ] = ( show ?
11704 ( positiveMotion ? "+=" : "-=") :
11705 ( positiveMotion ? "-=" : "+=")) +
11706 distance;
11707
11708 // Animate
11709 el.animate( animation, {
11710 queue: false,
11711 duration: o.duration,
11712 easing: o.easing,
11713 complete: function() {
11714 if ( mode === "hide" ) {
11715 el.hide();
11716 }
11717 $.effects.restore( el, props );
11718 $.effects.removeWrapper( el );
11719 done();
11720 }
11721 });
11722 };
11723
11724
11725 /*!
11726 * jQuery UI Effects Transfer 1.11.4
11727 * http://jqueryui.com
11728 *
11729 * Copyright jQuery Foundation and other contributors
11730 * Released under the MIT license.
11731 * http://jquery.org/license
11732 *
11733 * http://api.jqueryui.com/transfer-effect/
11734 */
11735
11736
11737 var effectTransfer = $.effects.effect.transfer = function( o, done ) {
11738 var elem = $( this ),
11739 target = $( o.to ),
11740 targetFixed = target.css( "position" ) === "fixed",
11741 body = $("body"),
11742 fixTop = targetFixed ? body.scrollTop() : 0,
11743 fixLeft = targetFixed ? body.scrollLeft() : 0,
11744 endPosition = target.offset(),
11745 animation = {
11746 top: endPosition.top - fixTop,
11747 left: endPosition.left - fixLeft,
11748 height: target.innerHeight(),
11749 width: target.innerWidth()
11750 },
11751 startPosition = elem.offset(),
11752 transfer = $( "<div class='ui-effects-transfer'></div>" )
11753 .appendTo( document.body )
11754 .addClass( o.className )
11755 .css({
11756 top: startPosition.top - fixTop,
11757 left: startPosition.left - fixLeft,
11758 height: elem.innerHeight(),
11759 width: elem.innerWidth(),
11760 position: targetFixed ? "fixed" : "absolute"
11761 })
11762 .animate( animation, o.duration, o.easing, function() {
11763 transfer.remove();
11764 done();
11765 });
11766 };
11767
11768
11769 /*!
11770 * jQuery UI Progressbar 1.11.4
11771 * http://jqueryui.com
11772 *
11773 * Copyright jQuery Foundation and other contributors
11774 * Released under the MIT license.
11775 * http://jquery.org/license
11776 *
11777 * http://api.jqueryui.com/progressbar/
11778 */
11779
11780
11781 var progressbar = $.widget( "ui.progressbar", {
11782 version: "1.11.4",
11783 options: {
11784 max: 100,
11785 value: 0,
11786
11787 change: null,
11788 complete: null
11789 },
11790
11791 min: 0,
11792
11793 _create: function() {
11794 // Constrain initial value
11795 this.oldValue = this.options.value = this._constrainedValue();
11796
11797 this.element
11798 .addClass( "ui-progressbar ui-widget ui-widget-content ui-corner-all" )
11799 .attr({
11800 // Only set static values, aria-valuenow and aria-valuemax are
11801 // set inside _refreshValue()
11802 role: "progressbar",
11803 "aria-valuemin": this.min
11804 });
11805
11806 this.valueDiv = $( "<div class='ui-progressbar-value ui-widget-header ui-corner-left'></div>" )
11807 .appendTo( this.element );
11808
11809 this._refreshValue();
11810 },
11811
11812 _destroy: function() {
11813 this.element
11814 .removeClass( "ui-progressbar ui-widget ui-widget-content ui-corner-all" )
11815 .removeAttr( "role" )
11816 .removeAttr( "aria-valuemin" )
11817 .removeAttr( "aria-valuemax" )
11818 .removeAttr( "aria-valuenow" );
11819
11820 this.valueDiv.remove();
11821 },
11822
11823 value: function( newValue ) {
11824 if ( newValue === undefined ) {
11825 return this.options.value;
11826 }
11827
11828 this.options.value = this._constrainedValue( newValue );
11829 this._refreshValue();
11830 },
11831
11832 _constrainedValue: function( newValue ) {
11833 if ( newValue === undefined ) {
11834 newValue = this.options.value;
11835 }
11836
11837 this.indeterminate = newValue === false;
11838
11839 // sanitize value
11840 if ( typeof newValue !== "number" ) {
11841 newValue = 0;
11842 }
11843
11844 return this.indeterminate ? false :
11845 Math.min( this.options.max, Math.max( this.min, newValue ) );
11846 },
11847
11848 _setOptions: function( options ) {
11849 // Ensure "value" option is set after other values (like max)
11850 var value = options.value;
11851 delete options.value;
11852
11853 this._super( options );
11854
11855 this.options.value = this._constrainedValue( value );
11856 this._refreshValue();
11857 },
11858
11859 _setOption: function( key, value ) {
11860 if ( key === "max" ) {
11861 // Don't allow a max less than min
11862 value = Math.max( this.min, value );
11863 }
11864 if ( key === "disabled" ) {
11865 this.element
11866 .toggleClass( "ui-state-disabled", !!value )
11867 .attr( "aria-disabled", value );
11868 }
11869 this._super( key, value );
11870 },
11871
11872 _percentage: function() {
11873 return this.indeterminate ? 100 : 100 * ( this.options.value - this.min ) / ( this.options.max - this.min );
11874 },
11875
11876 _refreshValue: function() {
11877 var value = this.options.value,
11878 percentage = this._percentage();
11879
11880 this.valueDiv
11881 .toggle( this.indeterminate || value > this.min )
11882 .toggleClass( "ui-corner-right", value === this.options.max )
11883 .width( percentage.toFixed(0) + "%" );
11884
11885 this.element.toggleClass( "ui-progressbar-indeterminate", this.indeterminate );
11886
11887 if ( this.indeterminate ) {
11888 this.element.removeAttr( "aria-valuenow" );
11889 if ( !this.overlayDiv ) {
11890 this.overlayDiv = $( "<div class='ui-progressbar-overlay'></div>" ).appendTo( this.valueDiv );
11891 }
11892 } else {
11893 this.element.attr({
11894 "aria-valuemax": this.options.max,
11895 "aria-valuenow": value
11896 });
11897 if ( this.overlayDiv ) {
11898 this.overlayDiv.remove();
11899 this.overlayDiv = null;
11900 }
11901 }
11902
11903 if ( this.oldValue !== value ) {
11904 this.oldValue = value;
11905 this._trigger( "change" );
11906 }
11907 if ( value === this.options.max ) {
11908 this._trigger( "complete" );
11909 }
11910 }
11911 });
11912
11913
11914 /*!
11915 * jQuery UI Selectable 1.11.4
11916 * http://jqueryui.com
11917 *
11918 * Copyright jQuery Foundation and other contributors
11919 * Released under the MIT license.
11920 * http://jquery.org/license
11921 *
11922 * http://api.jqueryui.com/selectable/
11923 */
11924
11925
11926 var selectable = $.widget("ui.selectable", $.ui.mouse, {
11927 version: "1.11.4",
11928 options: {
11929 appendTo: "body",
11930 autoRefresh: true,
11931 distance: 0,
11932 filter: "*",
11933 tolerance: "touch",
11934
11935 // callbacks
11936 selected: null,
11937 selecting: null,
11938 start: null,
11939 stop: null,
11940 unselected: null,
11941 unselecting: null
11942 },
11943 _create: function() {
11944 var selectees,
11945 that = this;
11946
11947 this.element.addClass("ui-selectable");
11948
11949 this.dragged = false;
11950
11951 // cache selectee children based on filter
11952 this.refresh = function() {
11953 selectees = $(that.options.filter, that.element[0]);
11954 selectees.addClass("ui-selectee");
11955 selectees.each(function() {
11956 var $this = $(this),
11957 pos = $this.offset();
11958 $.data(this, "selectable-item", {
11959 element: this,
11960 $element: $this,
11961 left: pos.left,
11962 top: pos.top,
11963 right: pos.left + $this.outerWidth(),
11964 bottom: pos.top + $this.outerHeight(),
11965 startselected: false,
11966 selected: $this.hasClass("ui-selected"),
11967 selecting: $this.hasClass("ui-selecting"),
11968 unselecting: $this.hasClass("ui-unselecting")
11969 });
11970 });
11971 };
11972 this.refresh();
11973
11974 this.selectees = selectees.addClass("ui-selectee");
11975
11976 this._mouseInit();
11977
11978 this.helper = $("<div class='ui-selectable-helper'></div>");
11979 },
11980
11981 _destroy: function() {
11982 this.selectees
11983 .removeClass("ui-selectee")
11984 .removeData("selectable-item");
11985 this.element
11986 .removeClass("ui-selectable ui-selectable-disabled");
11987 this._mouseDestroy();
11988 },
11989
11990 _mouseStart: function(event) {
11991 var that = this,
11992 options = this.options;
11993
11994 this.opos = [ event.pageX, event.pageY ];
11995
11996 if (this.options.disabled) {
11997 return;
11998 }
11999
12000 this.selectees = $(options.filter, this.element[0]);
12001
12002 this._trigger("start", event);
12003
12004 $(options.appendTo).append(this.helper);
12005 // position helper (lasso)
12006 this.helper.css({
12007 "left": event.pageX,
12008 "top": event.pageY,
12009 "width": 0,
12010 "height": 0
12011 });
12012
12013 if (options.autoRefresh) {
12014 this.refresh();
12015 }
12016
12017 this.selectees.filter(".ui-selected").each(function() {
12018 var selectee = $.data(this, "selectable-item");
12019 selectee.startselected = true;
12020 if (!event.metaKey && !event.ctrlKey) {
12021 selectee.$element.removeClass("ui-selected");
12022 selectee.selected = false;
12023 selectee.$element.addClass("ui-unselecting");
12024 selectee.unselecting = true;
12025 // selectable UNSELECTING callback
12026 that._trigger("unselecting", event, {
12027 unselecting: selectee.element
12028 });
12029 }
12030 });
12031
12032 $(event.target).parents().addBack().each(function() {
12033 var doSelect,
12034 selectee = $.data(this, "selectable-item");
12035 if (selectee) {
12036 doSelect = (!event.metaKey && !event.ctrlKey) || !selectee.$element.hasClass("ui-selected");
12037 selectee.$element
12038 .removeClass(doSelect ? "ui-unselecting" : "ui-selected")
12039 .addClass(doSelect ? "ui-selecting" : "ui-unselecting");
12040 selectee.unselecting = !doSelect;
12041 selectee.selecting = doSelect;
12042 selectee.selected = doSelect;
12043 // selectable (UN)SELECTING callback
12044 if (doSelect) {
12045 that._trigger("selecting", event, {
12046 selecting: selectee.element
12047 });
12048 } else {
12049 that._trigger("unselecting", event, {
12050 unselecting: selectee.element
12051 });
12052 }
12053 return false;
12054 }
12055 });
12056
12057 },
12058
12059 _mouseDrag: function(event) {
12060
12061 this.dragged = true;
12062
12063 if (this.options.disabled) {
12064 return;
12065 }
12066
12067 var tmp,
12068 that = this,
12069 options = this.options,
12070 x1 = this.opos[0],
12071 y1 = this.opos[1],
12072 x2 = event.pageX,
12073 y2 = event.pageY;
12074
12075 if (x1 > x2) { tmp = x2; x2 = x1; x1 = tmp; }
12076 if (y1 > y2) { tmp = y2; y2 = y1; y1 = tmp; }
12077 this.helper.css({ left: x1, top: y1, width: x2 - x1, height: y2 - y1 });
12078
12079 this.selectees.each(function() {
12080 var selectee = $.data(this, "selectable-item"),
12081 hit = false;
12082
12083 //prevent helper from being selected if appendTo: selectable
12084 if (!selectee || selectee.element === that.element[0]) {
12085 return;
12086 }
12087
12088 if (options.tolerance === "touch") {
12089 hit = ( !(selectee.left > x2 || selectee.right < x1 || selectee.top > y2 || selectee.bottom < y1) );
12090 } else if (options.tolerance === "fit") {
12091 hit = (selectee.left > x1 && selectee.right < x2 && selectee.top > y1 && selectee.bottom < y2);
12092 }
12093
12094 if (hit) {
12095 // SELECT
12096 if (selectee.selected) {
12097 selectee.$element.removeClass("ui-selected");
12098 selectee.selected = false;
12099 }
12100 if (selectee.unselecting) {
12101 selectee.$element.removeClass("ui-unselecting");
12102 selectee.unselecting = false;
12103 }
12104 if (!selectee.selecting) {
12105 selectee.$element.addClass("ui-selecting");
12106 selectee.selecting = true;
12107 // selectable SELECTING callback
12108 that._trigger("selecting", event, {
12109 selecting: selectee.element
12110 });
12111 }
12112 } else {
12113 // UNSELECT
12114 if (selectee.selecting) {
12115 if ((event.metaKey || event.ctrlKey) && selectee.startselected) {
12116 selectee.$element.removeClass("ui-selecting");
12117 selectee.selecting = false;
12118 selectee.$element.addClass("ui-selected");
12119 selectee.selected = true;
12120 } else {
12121 selectee.$element.removeClass("ui-selecting");
12122 selectee.selecting = false;
12123 if (selectee.startselected) {
12124 selectee.$element.addClass("ui-unselecting");
12125 selectee.unselecting = true;
12126 }
12127 // selectable UNSELECTING callback
12128 that._trigger("unselecting", event, {
12129 unselecting: selectee.element
12130 });
12131 }
12132 }
12133 if (selectee.selected) {
12134 if (!event.metaKey && !event.ctrlKey && !selectee.startselected) {
12135 selectee.$element.removeClass("ui-selected");
12136 selectee.selected = false;
12137
12138 selectee.$element.addClass("ui-unselecting");
12139 selectee.unselecting = true;
12140 // selectable UNSELECTING callback
12141 that._trigger("unselecting", event, {
12142 unselecting: selectee.element
12143 });
12144 }
12145 }
12146 }
12147 });
12148
12149 return false;
12150 },
12151
12152 _mouseStop: function(event) {
12153 var that = this;
12154
12155 this.dragged = false;
12156
12157 $(".ui-unselecting", this.element[0]).each(function() {
12158 var selectee = $.data(this, "selectable-item");
12159 selectee.$element.removeClass("ui-unselecting");
12160 selectee.unselecting = false;
12161 selectee.startselected = false;
12162 that._trigger("unselected", event, {
12163 unselected: selectee.element
12164 });
12165 });
12166 $(".ui-selecting", this.element[0]).each(function() {
12167 var selectee = $.data(this, "selectable-item");
12168 selectee.$element.removeClass("ui-selecting").addClass("ui-selected");
12169 selectee.selecting = false;
12170 selectee.selected = true;
12171 selectee.startselected = true;
12172 that._trigger("selected", event, {
12173 selected: selectee.element
12174 });
12175 });
12176 this._trigger("stop", event);
12177
12178 this.helper.remove();
12179
12180 return false;
12181 }
12182
12183 });
12184
12185
12186 /*!
12187 * jQuery UI Selectmenu 1.11.4
12188 * http://jqueryui.com
12189 *
12190 * Copyright jQuery Foundation and other contributors
12191 * Released under the MIT license.
12192 * http://jquery.org/license
12193 *
12194 * http://api.jqueryui.com/selectmenu
12195 */
12196
12197
12198 var selectmenu = $.widget( "ui.selectmenu", {
12199 version: "1.11.4",
12200 defaultElement: "<select>",
12201 options: {
12202 appendTo: null,
12203 disabled: null,
12204 icons: {
12205 button: "ui-icon-triangle-1-s"
12206 },
12207 position: {
12208 my: "left top",
12209 at: "left bottom",
12210 collision: "none"
12211 },
12212 width: null,
12213
12214 // callbacks
12215 change: null,
12216 close: null,
12217 focus: null,
12218 open: null,
12219 select: null
12220 },
12221
12222 _create: function() {
12223 var selectmenuId = this.element.uniqueId().attr( "id" );
12224 this.ids = {
12225 element: selectmenuId,
12226 button: selectmenuId + "-button",
12227 menu: selectmenuId + "-menu"
12228 };
12229
12230 this._drawButton();
12231 this._drawMenu();
12232
12233 if ( this.options.disabled ) {
12234 this.disable();
12235 }
12236 },
12237
12238 _drawButton: function() {
12239 var that = this;
12240
12241 // Associate existing label with the new button
12242 this.label = $( "label[for='" + this.ids.element + "']" ).attr( "for", this.ids.button );
12243 this._on( this.label, {
12244 click: function( event ) {
12245 this.button.focus();
12246 event.preventDefault();
12247 }
12248 });
12249
12250 // Hide original select element
12251 this.element.hide();
12252
12253 // Create button
12254 this.button = $( "<span>", {
12255 "class": "ui-selectmenu-button ui-widget ui-state-default ui-corner-all",
12256 tabindex: this.options.disabled ? -1 : 0,
12257 id: this.ids.button,
12258 role: "combobox",
12259 "aria-expanded": "false",
12260 "aria-autocomplete": "list",
12261 "aria-owns": this.ids.menu,
12262 "aria-haspopup": "true"
12263 })
12264 .insertAfter( this.element );
12265
12266 $( "<span>", {
12267 "class": "ui-icon " + this.options.icons.button
12268 })
12269 .prependTo( this.button );
12270
12271 this.buttonText = $( "<span>", {
12272 "class": "ui-selectmenu-text"
12273 })
12274 .appendTo( this.button );
12275
12276 this._setText( this.buttonText, this.element.find( "option:selected" ).text() );
12277 this._resizeButton();
12278
12279 this._on( this.button, this._buttonEvents );
12280 this.button.one( "focusin", function() {
12281
12282 // Delay rendering the menu items until the button receives focus.
12283 // The menu may have already been rendered via a programmatic open.
12284 if ( !that.menuItems ) {
12285 that._refreshMenu();
12286 }
12287 });
12288 this._hoverable( this.button );
12289 this._focusable( this.button );
12290 },
12291
12292 _drawMenu: function() {
12293 var that = this;
12294
12295 // Create menu
12296 this.menu = $( "<ul>", {
12297 "aria-hidden": "true",
12298 "aria-labelledby": this.ids.button,
12299 id: this.ids.menu
12300 });
12301
12302 // Wrap menu
12303 this.menuWrap = $( "<div>", {
12304 "class": "ui-selectmenu-menu ui-front"
12305 })
12306 .append( this.menu )
12307 .appendTo( this._appendTo() );
12308
12309 // Initialize menu widget
12310 this.menuInstance = this.menu
12311 .menu({
12312 role: "listbox",
12313 select: function( event, ui ) {
12314 event.preventDefault();
12315
12316 // support: IE8
12317 // If the item was selected via a click, the text selection
12318 // will be destroyed in IE
12319 that._setSelection();
12320
12321 that._select( ui.item.data( "ui-selectmenu-item" ), event );
12322 },
12323 focus: function( event, ui ) {
12324 var item = ui.item.data( "ui-selectmenu-item" );
12325
12326 // Prevent inital focus from firing and check if its a newly focused item
12327 if ( that.focusIndex != null && item.index !== that.focusIndex ) {
12328 that._trigger( "focus", event, { item: item } );
12329 if ( !that.isOpen ) {
12330 that._select( item, event );
12331 }
12332 }
12333 that.focusIndex = item.index;
12334
12335 that.button.attr( "aria-activedescendant",
12336 that.menuItems.eq( item.index ).attr( "id" ) );
12337 }
12338 })
12339 .menu( "instance" );
12340
12341 // Adjust menu styles to dropdown
12342 this.menu
12343 .addClass( "ui-corner-bottom" )
12344 .removeClass( "ui-corner-all" );
12345
12346 // Don't close the menu on mouseleave
12347 this.menuInstance._off( this.menu, "mouseleave" );
12348
12349 // Cancel the menu's collapseAll on document click
12350 this.menuInstance._closeOnDocumentClick = function() {
12351 return false;
12352 };
12353
12354 // Selects often contain empty items, but never contain dividers
12355 this.menuInstance._isDivider = function() {
12356 return false;
12357 };
12358 },
12359
12360 refresh: function() {
12361 this._refreshMenu();
12362 this._setText( this.buttonText, this._getSelectedItem().text() );
12363 if ( !this.options.width ) {
12364 this._resizeButton();
12365 }
12366 },
12367
12368 _refreshMenu: function() {
12369 this.menu.empty();
12370
12371 var item,
12372 options = this.element.find( "option" );
12373
12374 if ( !options.length ) {
12375 return;
12376 }
12377
12378 this._parseOptions( options );
12379 this._renderMenu( this.menu, this.items );
12380
12381 this.menuInstance.refresh();
12382 this.menuItems = this.menu.find( "li" ).not( ".ui-selectmenu-optgroup" );
12383
12384 item = this._getSelectedItem();
12385
12386 // Update the menu to have the correct item focused
12387 this.menuInstance.focus( null, item );
12388 this._setAria( item.data( "ui-selectmenu-item" ) );
12389
12390 // Set disabled state
12391 this._setOption( "disabled", this.element.prop( "disabled" ) );
12392 },
12393
12394 open: function( event ) {
12395 if ( this.options.disabled ) {
12396 return;
12397 }
12398
12399 // If this is the first time the menu is being opened, render the items
12400 if ( !this.menuItems ) {
12401 this._refreshMenu();
12402 } else {
12403
12404 // Menu clears focus on close, reset focus to selected item
12405 this.menu.find( ".ui-state-focus" ).removeClass( "ui-state-focus" );
12406 this.menuInstance.focus( null, this._getSelectedItem() );
12407 }
12408
12409 this.isOpen = true;
12410 this._toggleAttr();
12411 this._resizeMenu();
12412 this._position();
12413
12414 this._on( this.document, this._documentClick );
12415
12416 this._trigger( "open", event );
12417 },
12418
12419 _position: function() {
12420 this.menuWrap.position( $.extend( { of: this.button }, this.options.position ) );
12421 },
12422
12423 close: function( event ) {
12424 if ( !this.isOpen ) {
12425 return;
12426 }
12427
12428 this.isOpen = false;
12429 this._toggleAttr();
12430
12431 this.range = null;
12432 this._off( this.document );
12433
12434 this._trigger( "close", event );
12435 },
12436
12437 widget: function() {
12438 return this.button;
12439 },
12440
12441 menuWidget: function() {
12442 return this.menu;
12443 },
12444
12445 _renderMenu: function( ul, items ) {
12446 var that = this,
12447 currentOptgroup = "";
12448
12449 $.each( items, function( index, item ) {
12450 if ( item.optgroup !== currentOptgroup ) {
12451 $( "<li>", {
12452 "class": "ui-selectmenu-optgroup ui-menu-divider" +
12453 ( item.element.parent( "optgroup" ).prop( "disabled" ) ?
12454 " ui-state-disabled" :
12455 "" ),
12456 text: item.optgroup
12457 })
12458 .appendTo( ul );
12459
12460 currentOptgroup = item.optgroup;
12461 }
12462
12463 that._renderItemData( ul, item );
12464 });
12465 },
12466
12467 _renderItemData: function( ul, item ) {
12468 return this._renderItem( ul, item ).data( "ui-selectmenu-item", item );
12469 },
12470
12471 _renderItem: function( ul, item ) {
12472 var li = $( "<li>" );
12473
12474 if ( item.disabled ) {
12475 li.addClass( "ui-state-disabled" );
12476 }
12477 this._setText( li, item.label );
12478
12479 return li.appendTo( ul );
12480 },
12481
12482 _setText: function( element, value ) {
12483 if ( value ) {
12484 element.text( value );
12485 } else {
12486 element.html( " " );
12487 }
12488 },
12489
12490 _move: function( direction, event ) {
12491 var item, next,
12492 filter = ".ui-menu-item";
12493
12494 if ( this.isOpen ) {
12495 item = this.menuItems.eq( this.focusIndex );
12496 } else {
12497 item = this.menuItems.eq( this.element[ 0 ].selectedIndex );
12498 filter += ":not(.ui-state-disabled)";
12499 }
12500
12501 if ( direction === "first" || direction === "last" ) {
12502 next = item[ direction === "first" ? "prevAll" : "nextAll" ]( filter ).eq( -1 );
12503 } else {
12504 next = item[ direction + "All" ]( filter ).eq( 0 );
12505 }
12506
12507 if ( next.length ) {
12508 this.menuInstance.focus( event, next );
12509 }
12510 },
12511
12512 _getSelectedItem: function() {
12513 return this.menuItems.eq( this.element[ 0 ].selectedIndex );
12514 },
12515
12516 _toggle: function( event ) {
12517 this[ this.isOpen ? "close" : "open" ]( event );
12518 },
12519
12520 _setSelection: function() {
12521 var selection;
12522
12523 if ( !this.range ) {
12524 return;
12525 }
12526
12527 if ( window.getSelection ) {
12528 selection = window.getSelection();
12529 selection.removeAllRanges();
12530 selection.addRange( this.range );
12531
12532 // support: IE8
12533 } else {
12534 this.range.select();
12535 }
12536
12537 // support: IE
12538 // Setting the text selection kills the button focus in IE, but
12539 // restoring the focus doesn't kill the selection.
12540 this.button.focus();
12541 },
12542
12543 _documentClick: {
12544 mousedown: function( event ) {
12545 if ( !this.isOpen ) {
12546 return;
12547 }
12548
12549 if ( !$( event.target ).closest( ".ui-selectmenu-menu, #" + this.ids.button ).length ) {
12550 this.close( event );
12551 }
12552 }
12553 },
12554
12555 _buttonEvents: {
12556
12557 // Prevent text selection from being reset when interacting with the selectmenu (#10144)
12558 mousedown: function() {
12559 var selection;
12560
12561 if ( window.getSelection ) {
12562 selection = window.getSelection();
12563 if ( selection.rangeCount ) {
12564 this.range = selection.getRangeAt( 0 );
12565 }
12566
12567 // support: IE8
12568 } else {
12569 this.range = document.selection.createRange();
12570 }
12571 },
12572
12573 click: function( event ) {
12574 this._setSelection();
12575 this._toggle( event );
12576 },
12577
12578 keydown: function( event ) {
12579 var preventDefault = true;
12580 switch ( event.keyCode ) {
12581 case $.ui.keyCode.TAB:
12582 case $.ui.keyCode.ESCAPE:
12583 this.close( event );
12584 preventDefault = false;
12585 break;
12586 case $.ui.keyCode.ENTER:
12587 if ( this.isOpen ) {
12588 this._selectFocusedItem( event );
12589 }
12590 break;
12591 case $.ui.keyCode.UP:
12592 if ( event.altKey ) {
12593 this._toggle( event );
12594 } else {
12595 this._move( "prev", event );
12596 }
12597 break;
12598 case $.ui.keyCode.DOWN:
12599 if ( event.altKey ) {
12600 this._toggle( event );
12601 } else {
12602 this._move( "next", event );
12603 }
12604 break;
12605 case $.ui.keyCode.SPACE:
12606 if ( this.isOpen ) {
12607 this._selectFocusedItem( event );
12608 } else {
12609 this._toggle( event );
12610 }
12611 break;
12612 case $.ui.keyCode.LEFT:
12613 this._move( "prev", event );
12614 break;
12615 case $.ui.keyCode.RIGHT:
12616 this._move( "next", event );
12617 break;
12618 case $.ui.keyCode.HOME:
12619 case $.ui.keyCode.PAGE_UP:
12620 this._move( "first", event );
12621 break;
12622 case $.ui.keyCode.END:
12623 case $.ui.keyCode.PAGE_DOWN:
12624 this._move( "last", event );
12625 break;
12626 default:
12627 this.menu.trigger( event );
12628 preventDefault = false;
12629 }
12630
12631 if ( preventDefault ) {
12632 event.preventDefault();
12633 }
12634 }
12635 },
12636
12637 _selectFocusedItem: function( event ) {
12638 var item = this.menuItems.eq( this.focusIndex );
12639 if ( !item.hasClass( "ui-state-disabled" ) ) {
12640 this._select( item.data( "ui-selectmenu-item" ), event );
12641 }
12642 },
12643
12644 _select: function( item, event ) {
12645 var oldIndex = this.element[ 0 ].selectedIndex;
12646
12647 // Change native select element
12648 this.element[ 0 ].selectedIndex = item.index;
12649 this._setText( this.buttonText, item.label );
12650 this._setAria( item );
12651 this._trigger( "select", event, { item: item } );
12652
12653 if ( item.index !== oldIndex ) {
12654 this._trigger( "change", event, { item: item } );
12655 }
12656
12657 this.close( event );
12658 },
12659
12660 _setAria: function( item ) {
12661 var id = this.menuItems.eq( item.index ).attr( "id" );
12662
12663 this.button.attr({
12664 "aria-labelledby": id,
12665 "aria-activedescendant": id
12666 });
12667 this.menu.attr( "aria-activedescendant", id );
12668 },
12669
12670 _setOption: function( key, value ) {
12671 if ( key === "icons" ) {
12672 this.button.find( "span.ui-icon" )
12673 .removeClass( this.options.icons.button )
12674 .addClass( value.button );
12675 }
12676
12677 this._super( key, value );
12678
12679 if ( key === "appendTo" ) {
12680 this.menuWrap.appendTo( this._appendTo() );
12681 }
12682
12683 if ( key === "disabled" ) {
12684 this.menuInstance.option( "disabled", value );
12685 this.button
12686 .toggleClass( "ui-state-disabled", value )
12687 .attr( "aria-disabled", value );
12688
12689 this.element.prop( "disabled", value );
12690 if ( value ) {
12691 this.button.attr( "tabindex", -1 );
12692 this.close();
12693 } else {
12694 this.button.attr( "tabindex", 0 );
12695 }
12696 }
12697
12698 if ( key === "width" ) {
12699 this._resizeButton();
12700 }
12701 },
12702
12703 _appendTo: function() {
12704 var element = this.options.appendTo;
12705
12706 if ( element ) {
12707 element = element.jquery || element.nodeType ?
12708 $( element ) :
12709 this.document.find( element ).eq( 0 );
12710 }
12711
12712 if ( !element || !element[ 0 ] ) {
12713 element = this.element.closest( ".ui-front" );
12714 }
12715
12716 if ( !element.length ) {
12717 element = this.document[ 0 ].body;
12718 }
12719
12720 return element;
12721 },
12722
12723 _toggleAttr: function() {
12724 this.button
12725 .toggleClass( "ui-corner-top", this.isOpen )
12726 .toggleClass( "ui-corner-all", !this.isOpen )
12727 .attr( "aria-expanded", this.isOpen );
12728 this.menuWrap.toggleClass( "ui-selectmenu-open", this.isOpen );
12729 this.menu.attr( "aria-hidden", !this.isOpen );
12730 },
12731
12732 _resizeButton: function() {
12733 var width = this.options.width;
12734
12735 if ( !width ) {
12736 width = this.element.show().outerWidth();
12737 this.element.hide();
12738 }
12739
12740 this.button.outerWidth( width );
12741 },
12742
12743 _resizeMenu: function() {
12744 this.menu.outerWidth( Math.max(
12745 this.button.outerWidth(),
12746
12747 // support: IE10
12748 // IE10 wraps long text (possibly a rounding bug)
12749 // so we add 1px to avoid the wrapping
12750 this.menu.width( "" ).outerWidth() + 1
12751 ) );
12752 },
12753
12754 _getCreateOptions: function() {
12755 return { disabled: this.element.prop( "disabled" ) };
12756 },
12757
12758 _parseOptions: function( options ) {
12759 var data = [];
12760 options.each(function( index, item ) {
12761 var option = $( item ),
12762 optgroup = option.parent( "optgroup" );
12763 data.push({
12764 element: option,
12765 index: index,
12766 value: option.val(),
12767 label: option.text(),
12768 optgroup: optgroup.attr( "label" ) || "",
12769 disabled: optgroup.prop( "disabled" ) || option.prop( "disabled" )
12770 });
12771 });
12772 this.items = data;
12773 },
12774
12775 _destroy: function() {
12776 this.menuWrap.remove();
12777 this.button.remove();
12778 this.element.show();
12779 this.element.removeUniqueId();
12780 this.label.attr( "for", this.ids.element );
12781 }
12782 });
12783
12784
12785 /*!
12786 * jQuery UI Slider 1.11.4
12787 * http://jqueryui.com
12788 *
12789 * Copyright jQuery Foundation and other contributors
12790 * Released under the MIT license.
12791 * http://jquery.org/license
12792 *
12793 * http://api.jqueryui.com/slider/
12794 */
12795
12796
12797 var slider = $.widget( "ui.slider", $.ui.mouse, {
12798 version: "1.11.4",
12799 widgetEventPrefix: "slide",
12800
12801 options: {
12802 animate: false,
12803 distance: 0,
12804 max: 100,
12805 min: 0,
12806 orientation: "horizontal",
12807 range: false,
12808 step: 1,
12809 value: 0,
12810 values: null,
12811
12812 // callbacks
12813 change: null,
12814 slide: null,
12815 start: null,
12816 stop: null
12817 },
12818
12819 // number of pages in a slider
12820 // (how many times can you page up/down to go through the whole range)
12821 numPages: 5,
12822
12823 _create: function() {
12824 this._keySliding = false;
12825 this._mouseSliding = false;
12826 this._animateOff = true;
12827 this._handleIndex = null;
12828 this._detectOrientation();
12829 this._mouseInit();
12830 this._calculateNewMax();
12831
12832 this.element
12833 .addClass( "ui-slider" +
12834 " ui-slider-" + this.orientation +
12835 " ui-widget" +
12836 " ui-widget-content" +
12837 " ui-corner-all");
12838
12839 this._refresh();
12840 this._setOption( "disabled", this.options.disabled );
12841
12842 this._animateOff = false;
12843 },
12844
12845 _refresh: function() {
12846 this._createRange();
12847 this._createHandles();
12848 this._setupEvents();
12849 this._refreshValue();
12850 },
12851
12852 _createHandles: function() {
12853 var i, handleCount,
12854 options = this.options,
12855 existingHandles = this.element.find( ".ui-slider-handle" ).addClass( "ui-state-default ui-corner-all" ),
12856 handle = "<span class='ui-slider-handle ui-state-default ui-corner-all' tabindex='0'></span>",
12857 handles = [];
12858
12859 handleCount = ( options.values && options.values.length ) || 1;
12860
12861 if ( existingHandles.length > handleCount ) {
12862 existingHandles.slice( handleCount ).remove();
12863 existingHandles = existingHandles.slice( 0, handleCount );
12864 }
12865
12866 for ( i = existingHandles.length; i < handleCount; i++ ) {
12867 handles.push( handle );
12868 }
12869
12870 this.handles = existingHandles.add( $( handles.join( "" ) ).appendTo( this.element ) );
12871
12872 this.handle = this.handles.eq( 0 );
12873
12874 this.handles.each(function( i ) {
12875 $( this ).data( "ui-slider-handle-index", i );
12876 });
12877 },
12878
12879 _createRange: function() {
12880 var options = this.options,
12881 classes = "";
12882
12883 if ( options.range ) {
12884 if ( options.range === true ) {
12885 if ( !options.values ) {
12886 options.values = [ this._valueMin(), this._valueMin() ];
12887 } else if ( options.values.length && options.values.length !== 2 ) {
12888 options.values = [ options.values[0], options.values[0] ];
12889 } else if ( $.isArray( options.values ) ) {
12890 options.values = options.values.slice(0);
12891 }
12892 }
12893
12894 if ( !this.range || !this.range.length ) {
12895 this.range = $( "<div></div>" )
12896 .appendTo( this.element );
12897
12898 classes = "ui-slider-range" +
12899 // note: this isn't the most fittingly semantic framework class for this element,
12900 // but worked best visually with a variety of themes
12901 " ui-widget-header ui-corner-all";
12902 } else {
12903 this.range.removeClass( "ui-slider-range-min ui-slider-range-max" )
12904 // Handle range switching from true to min/max
12905 .css({
12906 "left": "",
12907 "bottom": ""
12908 });
12909 }
12910
12911 this.range.addClass( classes +
12912 ( ( options.range === "min" || options.range === "max" ) ? " ui-slider-range-" + options.range : "" ) );
12913 } else {
12914 if ( this.range ) {
12915 this.range.remove();
12916 }
12917 this.range = null;
12918 }
12919 },
12920
12921 _setupEvents: function() {
12922 this._off( this.handles );
12923 this._on( this.handles, this._handleEvents );
12924 this._hoverable( this.handles );
12925 this._focusable( this.handles );
12926 },
12927
12928 _destroy: function() {
12929 this.handles.remove();
12930 if ( this.range ) {
12931 this.range.remove();
12932 }
12933
12934 this.element
12935 .removeClass( "ui-slider" +
12936 " ui-slider-horizontal" +
12937 " ui-slider-vertical" +
12938 " ui-widget" +
12939 " ui-widget-content" +
12940 " ui-corner-all" );
12941
12942 this._mouseDestroy();
12943 },
12944
12945 _mouseCapture: function( event ) {
12946 var position, normValue, distance, closestHandle, index, allowed, offset, mouseOverHandle,
12947 that = this,
12948 o = this.options;
12949
12950 if ( o.disabled ) {
12951 return false;
12952 }
12953
12954 this.elementSize = {
12955 width: this.element.outerWidth(),
12956 height: this.element.outerHeight()
12957 };
12958 this.elementOffset = this.element.offset();
12959
12960 position = { x: event.pageX, y: event.pageY };
12961 normValue = this._normValueFromMouse( position );
12962 distance = this._valueMax() - this._valueMin() + 1;
12963 this.handles.each(function( i ) {
12964 var thisDistance = Math.abs( normValue - that.values(i) );
12965 if (( distance > thisDistance ) ||
12966 ( distance === thisDistance &&
12967 (i === that._lastChangedValue || that.values(i) === o.min ))) {
12968 distance = thisDistance;
12969 closestHandle = $( this );
12970 index = i;
12971 }
12972 });
12973
12974 allowed = this._start( event, index );
12975 if ( allowed === false ) {
12976 return false;
12977 }
12978 this._mouseSliding = true;
12979
12980 this._handleIndex = index;
12981
12982 closestHandle
12983 .addClass( "ui-state-active" )
12984 .focus();
12985
12986 offset = closestHandle.offset();
12987 mouseOverHandle = !$( event.target ).parents().addBack().is( ".ui-slider-handle" );
12988 this._clickOffset = mouseOverHandle ? { left: 0, top: 0 } : {
12989 left: event.pageX - offset.left - ( closestHandle.width() / 2 ),
12990 top: event.pageY - offset.top -
12991 ( closestHandle.height() / 2 ) -
12992 ( parseInt( closestHandle.css("borderTopWidth"), 10 ) || 0 ) -
12993 ( parseInt( closestHandle.css("borderBottomWidth"), 10 ) || 0) +
12994 ( parseInt( closestHandle.css("marginTop"), 10 ) || 0)
12995 };
12996
12997 if ( !this.handles.hasClass( "ui-state-hover" ) ) {
12998 this._slide( event, index, normValue );
12999 }
13000 this._animateOff = true;
13001 return true;
13002 },
13003
13004 _mouseStart: function() {
13005 return true;
13006 },
13007
13008 _mouseDrag: function( event ) {
13009 var position = { x: event.pageX, y: event.pageY },
13010 normValue = this._normValueFromMouse( position );
13011
13012 this._slide( event, this._handleIndex, normValue );
13013
13014 return false;
13015 },
13016
13017 _mouseStop: function( event ) {
13018 this.handles.removeClass( "ui-state-active" );
13019 this._mouseSliding = false;
13020
13021 this._stop( event, this._handleIndex );
13022 this._change( event, this._handleIndex );
13023
13024 this._handleIndex = null;
13025 this._clickOffset = null;
13026 this._animateOff = false;
13027
13028 return false;
13029 },
13030
13031 _detectOrientation: function() {
13032 this.orientation = ( this.options.orientation === "vertical" ) ? "vertical" : "horizontal";
13033 },
13034
13035 _normValueFromMouse: function( position ) {
13036 var pixelTotal,
13037 pixelMouse,
13038 percentMouse,
13039 valueTotal,
13040 valueMouse;
13041
13042 if ( this.orientation === "horizontal" ) {
13043 pixelTotal = this.elementSize.width;
13044 pixelMouse = position.x - this.elementOffset.left - ( this._clickOffset ? this._clickOffset.left : 0 );
13045 } else {
13046 pixelTotal = this.elementSize.height;
13047 pixelMouse = position.y - this.elementOffset.top - ( this._clickOffset ? this._clickOffset.top : 0 );
13048 }
13049
13050 percentMouse = ( pixelMouse / pixelTotal );
13051 if ( percentMouse > 1 ) {
13052 percentMouse = 1;
13053 }
13054 if ( percentMouse < 0 ) {
13055 percentMouse = 0;
13056 }
13057 if ( this.orientation === "vertical" ) {
13058 percentMouse = 1 - percentMouse;
13059 }
13060
13061 valueTotal = this._valueMax() - this._valueMin();
13062 valueMouse = this._valueMin() + percentMouse * valueTotal;
13063
13064 return this._trimAlignValue( valueMouse );
13065 },
13066
13067 _start: function( event, index ) {
13068 var uiHash = {
13069 handle: this.handles[ index ],
13070 value: this.value()
13071 };
13072 if ( this.options.values && this.options.values.length ) {
13073 uiHash.value = this.values( index );
13074 uiHash.values = this.values();
13075 }
13076 return this._trigger( "start", event, uiHash );
13077 },
13078
13079 _slide: function( event, index, newVal ) {
13080 var otherVal,
13081 newValues,
13082 allowed;
13083
13084 if ( this.options.values && this.options.values.length ) {
13085 otherVal = this.values( index ? 0 : 1 );
13086
13087 if ( ( this.options.values.length === 2 && this.options.range === true ) &&
13088 ( ( index === 0 && newVal > otherVal) || ( index === 1 && newVal < otherVal ) )
13089 ) {
13090 newVal = otherVal;
13091 }
13092
13093 if ( newVal !== this.values( index ) ) {
13094 newValues = this.values();
13095 newValues[ index ] = newVal;
13096 // A slide can be canceled by returning false from the slide callback
13097 allowed = this._trigger( "slide", event, {
13098 handle: this.handles[ index ],
13099 value: newVal,
13100 values: newValues
13101 } );
13102 otherVal = this.values( index ? 0 : 1 );
13103 if ( allowed !== false ) {
13104 this.values( index, newVal );
13105 }
13106 }
13107 } else {
13108 if ( newVal !== this.value() ) {
13109 // A slide can be canceled by returning false from the slide callback
13110 allowed = this._trigger( "slide", event, {
13111 handle: this.handles[ index ],
13112 value: newVal
13113 } );
13114 if ( allowed !== false ) {
13115 this.value( newVal );
13116 }
13117 }
13118 }
13119 },
13120
13121 _stop: function( event, index ) {
13122 var uiHash = {
13123 handle: this.handles[ index ],
13124 value: this.value()
13125 };
13126 if ( this.options.values && this.options.values.length ) {
13127 uiHash.value = this.values( index );
13128 uiHash.values = this.values();
13129 }
13130
13131 this._trigger( "stop", event, uiHash );
13132 },
13133
13134 _change: function( event, index ) {
13135 if ( !this._keySliding && !this._mouseSliding ) {
13136 var uiHash = {
13137 handle: this.handles[ index ],
13138 value: this.value()
13139 };
13140 if ( this.options.values && this.options.values.length ) {
13141 uiHash.value = this.values( index );
13142 uiHash.values = this.values();
13143 }
13144
13145 //store the last changed value index for reference when handles overlap
13146 this._lastChangedValue = index;
13147
13148 this._trigger( "change", event, uiHash );
13149 }
13150 },
13151
13152 value: function( newValue ) {
13153 if ( arguments.length ) {
13154 this.options.value = this._trimAlignValue( newValue );
13155 this._refreshValue();
13156 this._change( null, 0 );
13157 return;
13158 }
13159
13160 return this._value();
13161 },
13162
13163 values: function( index, newValue ) {
13164 var vals,
13165 newValues,
13166 i;
13167
13168 if ( arguments.length > 1 ) {
13169 this.options.values[ index ] = this._trimAlignValue( newValue );
13170 this._refreshValue();
13171 this._change( null, index );
13172 return;
13173 }
13174
13175 if ( arguments.length ) {
13176 if ( $.isArray( arguments[ 0 ] ) ) {
13177 vals = this.options.values;
13178 newValues = arguments[ 0 ];
13179 for ( i = 0; i < vals.length; i += 1 ) {
13180 vals[ i ] = this._trimAlignValue( newValues[ i ] );
13181 this._change( null, i );
13182 }
13183 this._refreshValue();
13184 } else {
13185 if ( this.options.values && this.options.values.length ) {
13186 return this._values( index );
13187 } else {
13188 return this.value();
13189 }
13190 }
13191 } else {
13192 return this._values();
13193 }
13194 },
13195
13196 _setOption: function( key, value ) {
13197 var i,
13198 valsLength = 0;
13199
13200 if ( key === "range" && this.options.range === true ) {
13201 if ( value === "min" ) {
13202 this.options.value = this._values( 0 );
13203 this.options.values = null;
13204 } else if ( value === "max" ) {
13205 this.options.value = this._values( this.options.values.length - 1 );
13206 this.options.values = null;
13207 }
13208 }
13209
13210 if ( $.isArray( this.options.values ) ) {
13211 valsLength = this.options.values.length;
13212 }
13213
13214 if ( key === "disabled" ) {
13215 this.element.toggleClass( "ui-state-disabled", !!value );
13216 }
13217
13218 this._super( key, value );
13219
13220 switch ( key ) {
13221 case "orientation":
13222 this._detectOrientation();
13223 this.element
13224 .removeClass( "ui-slider-horizontal ui-slider-vertical" )
13225 .addClass( "ui-slider-" + this.orientation );
13226 this._refreshValue();
13227
13228 // Reset positioning from previous orientation
13229 this.handles.css( value === "horizontal" ? "bottom" : "left", "" );
13230 break;
13231 case "value":
13232 this._animateOff = true;
13233 this._refreshValue();
13234 this._change( null, 0 );
13235 this._animateOff = false;
13236 break;
13237 case "values":
13238 this._animateOff = true;
13239 this._refreshValue();
13240 for ( i = 0; i < valsLength; i += 1 ) {
13241 this._change( null, i );
13242 }
13243 this._animateOff = false;
13244 break;
13245 case "step":
13246 case "min":
13247 case "max":
13248 this._animateOff = true;
13249 this._calculateNewMax();
13250 this._refreshValue();
13251 this._animateOff = false;
13252 break;
13253 case "range":
13254 this._animateOff = true;
13255 this._refresh();
13256 this._animateOff = false;
13257 break;
13258 }
13259 },
13260
13261 //internal value getter
13262 // _value() returns value trimmed by min and max, aligned by step
13263 _value: function() {
13264 var val = this.options.value;
13265 val = this._trimAlignValue( val );
13266
13267 return val;
13268 },
13269
13270 //internal values getter
13271 // _values() returns array of values trimmed by min and max, aligned by step
13272 // _values( index ) returns single value trimmed by min and max, aligned by step
13273 _values: function( index ) {
13274 var val,
13275 vals,
13276 i;
13277
13278 if ( arguments.length ) {
13279 val = this.options.values[ index ];
13280 val = this._trimAlignValue( val );
13281
13282 return val;
13283 } else if ( this.options.values && this.options.values.length ) {
13284 // .slice() creates a copy of the array
13285 // this copy gets trimmed by min and max and then returned
13286 vals = this.options.values.slice();
13287 for ( i = 0; i < vals.length; i += 1) {
13288 vals[ i ] = this._trimAlignValue( vals[ i ] );
13289 }
13290
13291 return vals;
13292 } else {
13293 return [];
13294 }
13295 },
13296
13297 // returns the step-aligned value that val is closest to, between (inclusive) min and max
13298 _trimAlignValue: function( val ) {
13299 if ( val <= this._valueMin() ) {
13300 return this._valueMin();
13301 }
13302 if ( val >= this._valueMax() ) {
13303 return this._valueMax();
13304 }
13305 var step = ( this.options.step > 0 ) ? this.options.step : 1,
13306 valModStep = (val - this._valueMin()) % step,
13307 alignValue = val - valModStep;
13308
13309 if ( Math.abs(valModStep) * 2 >= step ) {
13310 alignValue += ( valModStep > 0 ) ? step : ( -step );
13311 }
13312
13313 // Since JavaScript has problems with large floats, round
13314 // the final value to 5 digits after the decimal point (see #4124)
13315 return parseFloat( alignValue.toFixed(5) );
13316 },
13317
13318 _calculateNewMax: function() {
13319 var max = this.options.max,
13320 min = this._valueMin(),
13321 step = this.options.step,
13322 aboveMin = Math.floor( ( +( max - min ).toFixed( this._precision() ) ) / step ) * step;
13323 max = aboveMin + min;
13324 this.max = parseFloat( max.toFixed( this._precision() ) );
13325 },
13326
13327 _precision: function() {
13328 var precision = this._precisionOf( this.options.step );
13329 if ( this.options.min !== null ) {
13330 precision = Math.max( precision, this._precisionOf( this.options.min ) );
13331 }
13332 return precision;
13333 },
13334
13335 _precisionOf: function( num ) {
13336 var str = num.toString(),
13337 decimal = str.indexOf( "." );
13338 return decimal === -1 ? 0 : str.length - decimal - 1;
13339 },
13340
13341 _valueMin: function() {
13342 return this.options.min;
13343 },
13344
13345 _valueMax: function() {
13346 return this.max;
13347 },
13348
13349 _refreshValue: function() {
13350 var lastValPercent, valPercent, value, valueMin, valueMax,
13351 oRange = this.options.range,
13352 o = this.options,
13353 that = this,
13354 animate = ( !this._animateOff ) ? o.animate : false,
13355 _set = {};
13356
13357 if ( this.options.values && this.options.values.length ) {
13358 this.handles.each(function( i ) {
13359 valPercent = ( that.values(i) - that._valueMin() ) / ( that._valueMax() - that._valueMin() ) * 100;
13360 _set[ that.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
13361 $( this ).stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
13362 if ( that.options.range === true ) {
13363 if ( that.orientation === "horizontal" ) {
13364 if ( i === 0 ) {
13365 that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { left: valPercent + "%" }, o.animate );
13366 }
13367 if ( i === 1 ) {
13368 that.range[ animate ? "animate" : "css" ]( { width: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
13369 }
13370 } else {
13371 if ( i === 0 ) {
13372 that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { bottom: ( valPercent ) + "%" }, o.animate );
13373 }
13374 if ( i === 1 ) {
13375 that.range[ animate ? "animate" : "css" ]( { height: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
13376 }
13377 }
13378 }
13379 lastValPercent = valPercent;
13380 });
13381 } else {
13382 value = this.value();
13383 valueMin = this._valueMin();
13384 valueMax = this._valueMax();
13385 valPercent = ( valueMax !== valueMin ) ?
13386 ( value - valueMin ) / ( valueMax - valueMin ) * 100 :
13387 0;
13388 _set[ this.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
13389 this.handle.stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
13390
13391 if ( oRange === "min" && this.orientation === "horizontal" ) {
13392 this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { width: valPercent + "%" }, o.animate );
13393 }
13394 if ( oRange === "max" && this.orientation === "horizontal" ) {
13395 this.range[ animate ? "animate" : "css" ]( { width: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
13396 }
13397 if ( oRange === "min" && this.orientation === "vertical" ) {
13398 this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { height: valPercent + "%" }, o.animate );
13399 }
13400 if ( oRange === "max" && this.orientation === "vertical" ) {
13401 this.range[ animate ? "animate" : "css" ]( { height: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
13402 }
13403 }
13404 },
13405
13406 _handleEvents: {
13407 keydown: function( event ) {
13408 var allowed, curVal, newVal, step,
13409 index = $( event.target ).data( "ui-slider-handle-index" );
13410
13411 switch ( event.keyCode ) {
13412 case $.ui.keyCode.HOME:
13413 case $.ui.keyCode.END:
13414 case $.ui.keyCode.PAGE_UP:
13415 case $.ui.keyCode.PAGE_DOWN:
13416 case $.ui.keyCode.UP:
13417 case $.ui.keyCode.RIGHT:
13418 case $.ui.keyCode.DOWN:
13419 case $.ui.keyCode.LEFT:
13420 event.preventDefault();
13421 if ( !this._keySliding ) {
13422 this._keySliding = true;
13423 $( event.target ).addClass( "ui-state-active" );
13424 allowed = this._start( event, index );
13425 if ( allowed === false ) {
13426 return;
13427 }
13428 }
13429 break;
13430 }
13431
13432 step = this.options.step;
13433 if ( this.options.values && this.options.values.length ) {
13434 curVal = newVal = this.values( index );
13435 } else {
13436 curVal = newVal = this.value();
13437 }
13438
13439 switch ( event.keyCode ) {
13440 case $.ui.keyCode.HOME:
13441 newVal = this._valueMin();
13442 break;
13443 case $.ui.keyCode.END:
13444 newVal = this._valueMax();
13445 break;
13446 case $.ui.keyCode.PAGE_UP:
13447 newVal = this._trimAlignValue(
13448 curVal + ( ( this._valueMax() - this._valueMin() ) / this.numPages )
13449 );
13450 break;
13451 case $.ui.keyCode.PAGE_DOWN:
13452 newVal = this._trimAlignValue(
13453 curVal - ( (this._valueMax() - this._valueMin()) / this.numPages ) );
13454 break;
13455 case $.ui.keyCode.UP:
13456 case $.ui.keyCode.RIGHT:
13457 if ( curVal === this._valueMax() ) {
13458 return;
13459 }
13460 newVal = this._trimAlignValue( curVal + step );
13461 break;
13462 case $.ui.keyCode.DOWN:
13463 case $.ui.keyCode.LEFT:
13464 if ( curVal === this._valueMin() ) {
13465 return;
13466 }
13467 newVal = this._trimAlignValue( curVal - step );
13468 break;
13469 }
13470
13471 this._slide( event, index, newVal );
13472 },
13473 keyup: function( event ) {
13474 var index = $( event.target ).data( "ui-slider-handle-index" );
13475
13476 if ( this._keySliding ) {
13477 this._keySliding = false;
13478 this._stop( event, index );
13479 this._change( event, index );
13480 $( event.target ).removeClass( "ui-state-active" );
13481 }
13482 }
13483 }
13484 });
13485
13486
13487 /*!
13488 * jQuery UI Sortable 1.11.4
13489 * http://jqueryui.com
13490 *
13491 * Copyright jQuery Foundation and other contributors
13492 * Released under the MIT license.
13493 * http://jquery.org/license
13494 *
13495 * http://api.jqueryui.com/sortable/
13496 */
13497
13498
13499 var sortable = $.widget("ui.sortable", $.ui.mouse, {
13500 version: "1.11.4",
13501 widgetEventPrefix: "sort",
13502 ready: false,
13503 options: {
13504 appendTo: "parent",
13505 axis: false,
13506 connectWith: false,
13507 containment: false,
13508 cursor: "auto",
13509 cursorAt: false,
13510 dropOnEmpty: true,
13511 forcePlaceholderSize: false,
13512 forceHelperSize: false,
13513 grid: false,
13514 handle: false,
13515 helper: "original",
13516 items: "> *",
13517 opacity: false,
13518 placeholder: false,
13519 revert: false,
13520 scroll: true,
13521 scrollSensitivity: 20,
13522 scrollSpeed: 20,
13523 scope: "default",
13524 tolerance: "intersect",
13525 zIndex: 1000,
13526
13527 // callbacks
13528 activate: null,
13529 beforeStop: null,
13530 change: null,
13531 deactivate: null,
13532 out: null,
13533 over: null,
13534 receive: null,
13535 remove: null,
13536 sort: null,
13537 start: null,
13538 stop: null,
13539 update: null
13540 },
13541
13542 _isOverAxis: function( x, reference, size ) {
13543 return ( x >= reference ) && ( x < ( reference + size ) );
13544 },
13545
13546 _isFloating: function( item ) {
13547 return (/left|right/).test(item.css("float")) || (/inline|table-cell/).test(item.css("display"));
13548 },
13549
13550 _create: function() {
13551 this.containerCache = {};
13552 this.element.addClass("ui-sortable");
13553
13554 //Get the items
13555 this.refresh();
13556
13557 //Let's determine the parent's offset
13558 this.offset = this.element.offset();
13559
13560 //Initialize mouse events for interaction
13561 this._mouseInit();
13562
13563 this._setHandleClassName();
13564
13565 //We're ready to go
13566 this.ready = true;
13567
13568 },
13569
13570 _setOption: function( key, value ) {
13571 this._super( key, value );
13572
13573 if ( key === "handle" ) {
13574 this._setHandleClassName();
13575 }
13576 },
13577
13578 _setHandleClassName: function() {
13579 this.element.find( ".ui-sortable-handle" ).removeClass( "ui-sortable-handle" );
13580 $.each( this.items, function() {
13581 ( this.instance.options.handle ?
13582 this.item.find( this.instance.options.handle ) : this.item )
13583 .addClass( "ui-sortable-handle" );
13584 });
13585 },
13586
13587 _destroy: function() {
13588 this.element
13589 .removeClass( "ui-sortable ui-sortable-disabled" )
13590 .find( ".ui-sortable-handle" )
13591 .removeClass( "ui-sortable-handle" );
13592 this._mouseDestroy();
13593
13594 for ( var i = this.items.length - 1; i >= 0; i-- ) {
13595 this.items[i].item.removeData(this.widgetName + "-item");
13596 }
13597
13598 return this;
13599 },
13600
13601 _mouseCapture: function(event, overrideHandle) {
13602 var currentItem = null,
13603 validHandle = false,
13604 that = this;
13605
13606 if (this.reverting) {
13607 return false;
13608 }
13609
13610 if(this.options.disabled || this.options.type === "static") {
13611 return false;
13612 }
13613
13614 //We have to refresh the items data once first
13615 this._refreshItems(event);
13616
13617 //Find out if the clicked node (or one of its parents) is a actual item in this.items
13618 $(event.target).parents().each(function() {
13619 if($.data(this, that.widgetName + "-item") === that) {
13620 currentItem = $(this);
13621 return false;
13622 }
13623 });
13624 if($.data(event.target, that.widgetName + "-item") === that) {
13625 currentItem = $(event.target);
13626 }
13627
13628 if(!currentItem) {
13629 return false;
13630 }
13631 if(this.options.handle && !overrideHandle) {
13632 $(this.options.handle, currentItem).find("*").addBack().each(function() {
13633 if(this === event.target) {
13634 validHandle = true;
13635 }
13636 });
13637 if(!validHandle) {
13638 return false;
13639 }
13640 }
13641
13642 this.currentItem = currentItem;
13643 this._removeCurrentsFromItems();
13644 return true;
13645
13646 },
13647
13648 _mouseStart: function(event, overrideHandle, noActivation) {
13649
13650 var i, body,
13651 o = this.options;
13652
13653 this.currentContainer = this;
13654
13655 //We only need to call refreshPositions, because the refreshItems call has been moved to mouseCapture
13656 this.refreshPositions();
13657
13658 //Create and append the visible helper
13659 this.helper = this._createHelper(event);
13660
13661 //Cache the helper size
13662 this._cacheHelperProportions();
13663
13664 /*
13665 * - Position generation -
13666 * This block generates everything position related - it's the core of draggables.
13667 */
13668
13669 //Cache the margins of the original element
13670 this._cacheMargins();
13671
13672 //Get the next scrolling parent
13673 this.scrollParent = this.helper.scrollParent();
13674
13675 //The element's absolute position on the page minus margins
13676 this.offset = this.currentItem.offset();
13677 this.offset = {
13678 top: this.offset.top - this.margins.top,
13679 left: this.offset.left - this.margins.left
13680 };
13681
13682 $.extend(this.offset, {
13683 click: { //Where the click happened, relative to the element
13684 left: event.pageX - this.offset.left,
13685 top: event.pageY - this.offset.top
13686 },
13687 parent: this._getParentOffset(),
13688 relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
13689 });
13690
13691 // Only after we got the offset, we can change the helper's position to absolute
13692 // TODO: Still need to figure out a way to make relative sorting possible
13693 this.helper.css("position", "absolute");
13694 this.cssPosition = this.helper.css("position");
13695
13696 //Generate the original position
13697 this.originalPosition = this._generatePosition(event);
13698 this.originalPageX = event.pageX;
13699 this.originalPageY = event.pageY;
13700
13701 //Adjust the mouse offset relative to the helper if "cursorAt" is supplied
13702 (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
13703
13704 //Cache the former DOM position
13705 this.domPosition = { prev: this.currentItem.prev()[0], parent: this.currentItem.parent()[0] };
13706
13707 //If the helper is not the original, hide the original so it's not playing any role during the drag, won't cause anything bad this way
13708 if(this.helper[0] !== this.currentItem[0]) {
13709 this.currentItem.hide();
13710 }
13711
13712 //Create the placeholder
13713 this._createPlaceholder();
13714
13715 //Set a containment if given in the options
13716 if(o.containment) {
13717 this._setContainment();
13718 }
13719
13720 if( o.cursor && o.cursor !== "auto" ) { // cursor option
13721 body = this.document.find( "body" );
13722
13723 // support: IE
13724 this.storedCursor = body.css( "cursor" );
13725 body.css( "cursor", o.cursor );
13726
13727 this.storedStylesheet = $( "<style>*{ cursor: "+o.cursor+" !important; }</style>" ).appendTo( body );
13728 }
13729
13730 if(o.opacity) { // opacity option
13731 if (this.helper.css("opacity")) {
13732 this._storedOpacity = this.helper.css("opacity");
13733 }
13734 this.helper.css("opacity", o.opacity);
13735 }
13736
13737 if(o.zIndex) { // zIndex option
13738 if (this.helper.css("zIndex")) {
13739 this._storedZIndex = this.helper.css("zIndex");
13740 }
13741 this.helper.css("zIndex", o.zIndex);
13742 }
13743
13744 //Prepare scrolling
13745 if(this.scrollParent[0] !== this.document[0] && this.scrollParent[0].tagName !== "HTML") {
13746 this.overflowOffset = this.scrollParent.offset();
13747 }
13748
13749 //Call callbacks
13750 this._trigger("start", event, this._uiHash());
13751
13752 //Recache the helper size
13753 if(!this._preserveHelperProportions) {
13754 this._cacheHelperProportions();
13755 }
13756
13757
13758 //Post "activate" events to possible containers
13759 if( !noActivation ) {
13760 for ( i = this.containers.length - 1; i >= 0; i-- ) {
13761 this.containers[ i ]._trigger( "activate", event, this._uiHash( this ) );
13762 }
13763 }
13764
13765 //Prepare possible droppables
13766 if($.ui.ddmanager) {
13767 $.ui.ddmanager.current = this;
13768 }
13769
13770 if ($.ui.ddmanager && !o.dropBehaviour) {
13771 $.ui.ddmanager.prepareOffsets(this, event);
13772 }
13773
13774 this.dragging = true;
13775
13776 this.helper.addClass("ui-sortable-helper");
13777 this._mouseDrag(event); //Execute the drag once - this causes the helper not to be visible before getting its correct position
13778 return true;
13779
13780 },
13781
13782 _mouseDrag: function(event) {
13783 var i, item, itemElement, intersection,
13784 o = this.options,
13785 scrolled = false;
13786
13787 //Compute the helpers position
13788 this.position = this._generatePosition(event);
13789 this.positionAbs = this._convertPositionTo("absolute");
13790
13791 if (!this.lastPositionAbs) {
13792 this.lastPositionAbs = this.positionAbs;
13793 }
13794
13795 //Do scrolling
13796 if(this.options.scroll) {
13797 if(this.scrollParent[0] !== this.document[0] && this.scrollParent[0].tagName !== "HTML") {
13798
13799 if((this.overflowOffset.top + this.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity) {
13800 this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop + o.scrollSpeed;
13801 } else if(event.pageY - this.overflowOffset.top < o.scrollSensitivity) {
13802 this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop - o.scrollSpeed;
13803 }
13804
13805 if((this.overflowOffset.left + this.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity) {
13806 this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft + o.scrollSpeed;
13807 } else if(event.pageX - this.overflowOffset.left < o.scrollSensitivity) {
13808 this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft - o.scrollSpeed;
13809 }
13810
13811 } else {
13812
13813 if(event.pageY - this.document.scrollTop() < o.scrollSensitivity) {
13814 scrolled = this.document.scrollTop(this.document.scrollTop() - o.scrollSpeed);
13815 } else if(this.window.height() - (event.pageY - this.document.scrollTop()) < o.scrollSensitivity) {
13816 scrolled = this.document.scrollTop(this.document.scrollTop() + o.scrollSpeed);
13817 }
13818
13819 if(event.pageX - this.document.scrollLeft() < o.scrollSensitivity) {
13820 scrolled = this.document.scrollLeft(this.document.scrollLeft() - o.scrollSpeed);
13821 } else if(this.window.width() - (event.pageX - this.document.scrollLeft()) < o.scrollSensitivity) {
13822 scrolled = this.document.scrollLeft(this.document.scrollLeft() + o.scrollSpeed);
13823 }
13824
13825 }
13826
13827 if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
13828 $.ui.ddmanager.prepareOffsets(this, event);
13829 }
13830 }
13831
13832 //Regenerate the absolute position used for position checks
13833 this.positionAbs = this._convertPositionTo("absolute");
13834
13835 //Set the helper position
13836 if(!this.options.axis || this.options.axis !== "y") {
13837 this.helper[0].style.left = this.position.left+"px";
13838 }
13839 if(!this.options.axis || this.options.axis !== "x") {
13840 this.helper[0].style.top = this.position.top+"px";
13841 }
13842
13843 //Rearrange
13844 for (i = this.items.length - 1; i >= 0; i--) {
13845
13846 //Cache variables and intersection, continue if no intersection
13847 item = this.items[i];
13848 itemElement = item.item[0];
13849 intersection = this._intersectsWithPointer(item);
13850 if (!intersection) {
13851 continue;
13852 }
13853
13854 // Only put the placeholder inside the current Container, skip all
13855 // items from other containers. This works because when moving
13856 // an item from one container to another the
13857 // currentContainer is switched before the placeholder is moved.
13858 //
13859 // Without this, moving items in "sub-sortables" can cause
13860 // the placeholder to jitter between the outer and inner container.
13861 if (item.instance !== this.currentContainer) {
13862 continue;
13863 }
13864
13865 // cannot intersect with itself
13866 // no useless actions that have been done before
13867 // no action if the item moved is the parent of the item checked
13868 if (itemElement !== this.currentItem[0] &&
13869 this.placeholder[intersection === 1 ? "next" : "prev"]()[0] !== itemElement &&
13870 !$.contains(this.placeholder[0], itemElement) &&
13871 (this.options.type === "semi-dynamic" ? !$.contains(this.element[0], itemElement) : true)
13872 ) {
13873
13874 this.direction = intersection === 1 ? "down" : "up";
13875
13876 if (this.options.tolerance === "pointer" || this._intersectsWithSides(item)) {
13877 this._rearrange(event, item);
13878 } else {
13879 break;
13880 }
13881
13882 this._trigger("change", event, this._uiHash());
13883 break;
13884 }
13885 }
13886
13887 //Post events to containers
13888 this._contactContainers(event);
13889
13890 //Interconnect with droppables
13891 if($.ui.ddmanager) {
13892 $.ui.ddmanager.drag(this, event);
13893 }
13894
13895 //Call callbacks
13896 this._trigger("sort", event, this._uiHash());
13897
13898 this.lastPositionAbs = this.positionAbs;
13899 return false;
13900
13901 },
13902
13903 _mouseStop: function(event, noPropagation) {
13904
13905 if(!event) {
13906 return;
13907 }
13908
13909 //If we are using droppables, inform the manager about the drop
13910 if ($.ui.ddmanager && !this.options.dropBehaviour) {
13911 $.ui.ddmanager.drop(this, event);
13912 }
13913
13914 if(this.options.revert) {
13915 var that = this,
13916 cur = this.placeholder.offset(),
13917 axis = this.options.axis,
13918 animation = {};
13919
13920 if ( !axis || axis === "x" ) {
13921 animation.left = cur.left - this.offset.parent.left - this.margins.left + (this.offsetParent[0] === this.document[0].body ? 0 : this.offsetParent[0].scrollLeft);
13922 }
13923 if ( !axis || axis === "y" ) {
13924 animation.top = cur.top - this.offset.parent.top - this.margins.top + (this.offsetParent[0] === this.document[0].body ? 0 : this.offsetParent[0].scrollTop);
13925 }
13926 this.reverting = true;
13927 $(this.helper).animate( animation, parseInt(this.options.revert, 10) || 500, function() {
13928 that._clear(event);
13929 });
13930 } else {
13931 this._clear(event, noPropagation);
13932 }
13933
13934 return false;
13935
13936 },
13937
13938 cancel: function() {
13939
13940 if(this.dragging) {
13941
13942 this._mouseUp({ target: null });
13943
13944 if(this.options.helper === "original") {
13945 this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
13946 } else {
13947 this.currentItem.show();
13948 }
13949
13950 //Post deactivating events to containers
13951 for (var i = this.containers.length - 1; i >= 0; i--){
13952 this.containers[i]._trigger("deactivate", null, this._uiHash(this));
13953 if(this.containers[i].containerCache.over) {
13954 this.containers[i]._trigger("out", null, this._uiHash(this));
13955 this.containers[i].containerCache.over = 0;
13956 }
13957 }
13958
13959 }
13960
13961 if (this.placeholder) {
13962 //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
13963 if(this.placeholder[0].parentNode) {
13964 this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
13965 }
13966 if(this.options.helper !== "original" && this.helper && this.helper[0].parentNode) {
13967 this.helper.remove();
13968 }
13969
13970 $.extend(this, {
13971 helper: null,
13972 dragging: false,
13973 reverting: false,
13974 _noFinalSort: null
13975 });
13976
13977 if(this.domPosition.prev) {
13978 $(this.domPosition.prev).after(this.currentItem);
13979 } else {
13980 $(this.domPosition.parent).prepend(this.currentItem);
13981 }
13982 }
13983
13984 return this;
13985
13986 },
13987
13988 serialize: function(o) {
13989
13990 var items = this._getItemsAsjQuery(o && o.connected),
13991 str = [];
13992 o = o || {};
13993
13994 $(items).each(function() {
13995 var res = ($(o.item || this).attr(o.attribute || "id") || "").match(o.expression || (/(.+)[\-=_](.+)/));
13996 if (res) {
13997 str.push((o.key || res[1]+"[]")+"="+(o.key && o.expression ? res[1] : res[2]));
13998 }
13999 });
14000
14001 if(!str.length && o.key) {
14002 str.push(o.key + "=");
14003 }
14004
14005 return str.join("&");
14006
14007 },
14008
14009 toArray: function(o) {
14010
14011 var items = this._getItemsAsjQuery(o && o.connected),
14012 ret = [];
14013
14014 o = o || {};
14015
14016 items.each(function() { ret.push($(o.item || this).attr(o.attribute || "id") || ""); });
14017 return ret;
14018
14019 },
14020
14021 /* Be careful with the following core functions */
14022 _intersectsWith: function(item) {
14023
14024 var x1 = this.positionAbs.left,
14025 x2 = x1 + this.helperProportions.width,
14026 y1 = this.positionAbs.top,
14027 y2 = y1 + this.helperProportions.height,
14028 l = item.left,
14029 r = l + item.width,
14030 t = item.top,
14031 b = t + item.height,
14032 dyClick = this.offset.click.top,
14033 dxClick = this.offset.click.left,
14034 isOverElementHeight = ( this.options.axis === "x" ) || ( ( y1 + dyClick ) > t && ( y1 + dyClick ) < b ),
14035 isOverElementWidth = ( this.options.axis === "y" ) || ( ( x1 + dxClick ) > l && ( x1 + dxClick ) < r ),
14036 isOverElement = isOverElementHeight && isOverElementWidth;
14037
14038 if ( this.options.tolerance === "pointer" ||
14039 this.options.forcePointerForContainers ||
14040 (this.options.tolerance !== "pointer" && this.helperProportions[this.floating ? "width" : "height"] > item[this.floating ? "width" : "height"])
14041 ) {
14042 return isOverElement;
14043 } else {
14044
14045 return (l < x1 + (this.helperProportions.width / 2) && // Right Half
14046 x2 - (this.helperProportions.width / 2) < r && // Left Half
14047 t < y1 + (this.helperProportions.height / 2) && // Bottom Half
14048 y2 - (this.helperProportions.height / 2) < b ); // Top Half
14049
14050 }
14051 },
14052
14053 _intersectsWithPointer: function(item) {
14054
14055 var isOverElementHeight = (this.options.axis === "x") || this._isOverAxis(this.positionAbs.top + this.offset.click.top, item.top, item.height),
14056 isOverElementWidth = (this.options.axis === "y") || this._isOverAxis(this.positionAbs.left + this.offset.click.left, item.left, item.width),
14057 isOverElement = isOverElementHeight && isOverElementWidth,
14058 verticalDirection = this._getDragVerticalDirection(),
14059 horizontalDirection = this._getDragHorizontalDirection();
14060
14061 if (!isOverElement) {
14062 return false;
14063 }
14064
14065 return this.floating ?
14066 ( ((horizontalDirection && horizontalDirection === "right") || verticalDirection === "down") ? 2 : 1 )
14067 : ( verticalDirection && (verticalDirection === "down" ? 2 : 1) );
14068
14069 },
14070
14071 _intersectsWithSides: function(item) {
14072
14073 var isOverBottomHalf = this._isOverAxis(this.positionAbs.top + this.offset.click.top, item.top + (item.height/2), item.height),
14074 isOverRightHalf = this._isOverAxis(this.positionAbs.left + this.offset.click.left, item.left + (item.width/2), item.width),
14075 verticalDirection = this._getDragVerticalDirection(),
14076 horizontalDirection = this._getDragHorizontalDirection();
14077
14078 if (this.floating && horizontalDirection) {
14079 return ((horizontalDirection === "right" && isOverRightHalf) || (horizontalDirection === "left" && !isOverRightHalf));
14080 } else {
14081 return verticalDirection && ((verticalDirection === "down" && isOverBottomHalf) || (verticalDirection === "up" && !isOverBottomHalf));
14082 }
14083
14084 },
14085
14086 _getDragVerticalDirection: function() {
14087 var delta = this.positionAbs.top - this.lastPositionAbs.top;
14088 return delta !== 0 && (delta > 0 ? "down" : "up");
14089 },
14090
14091 _getDragHorizontalDirection: function() {
14092 var delta = this.positionAbs.left - this.lastPositionAbs.left;
14093 return delta !== 0 && (delta > 0 ? "right" : "left");
14094 },
14095
14096 refresh: function(event) {
14097 this._refreshItems(event);
14098 this._setHandleClassName();
14099 this.refreshPositions();
14100 return this;
14101 },
14102
14103 _connectWith: function() {
14104 var options = this.options;
14105 return options.connectWith.constructor === String ? [options.connectWith] : options.connectWith;
14106 },
14107
14108 _getItemsAsjQuery: function(connected) {
14109
14110 var i, j, cur, inst,
14111 items = [],
14112 queries = [],
14113 connectWith = this._connectWith();
14114
14115 if(connectWith && connected) {
14116 for (i = connectWith.length - 1; i >= 0; i--){
14117 cur = $(connectWith[i], this.document[0]);
14118 for ( j = cur.length - 1; j >= 0; j--){
14119 inst = $.data(cur[j], this.widgetFullName);
14120 if(inst && inst !== this && !inst.options.disabled) {
14121 queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element) : $(inst.options.items, inst.element).not(".ui-sortable-helper").not(".ui-sortable-placeholder"), inst]);
14122 }
14123 }
14124 }
14125 }
14126
14127 queries.push([$.isFunction(this.options.items) ? this.options.items.call(this.element, null, { options: this.options, item: this.currentItem }) : $(this.options.items, this.element).not(".ui-sortable-helper").not(".ui-sortable-placeholder"), this]);
14128
14129 function addItems() {
14130 items.push( this );
14131 }
14132 for (i = queries.length - 1; i >= 0; i--){
14133 queries[i][0].each( addItems );
14134 }
14135
14136 return $(items);
14137
14138 },
14139
14140 _removeCurrentsFromItems: function() {
14141
14142 var list = this.currentItem.find(":data(" + this.widgetName + "-item)");
14143
14144 this.items = $.grep(this.items, function (item) {
14145 for (var j=0; j < list.length; j++) {
14146 if(list[j] === item.item[0]) {
14147 return false;
14148 }
14149 }
14150 return true;
14151 });
14152
14153 },
14154
14155 _refreshItems: function(event) {
14156
14157 this.items = [];
14158 this.containers = [this];
14159
14160 var i, j, cur, inst, targetData, _queries, item, queriesLength,
14161 items = this.items,
14162 queries = [[$.isFunction(this.options.items) ? this.options.items.call(this.element[0], event, { item: this.currentItem }) : $(this.options.items, this.element), this]],
14163 connectWith = this._connectWith();
14164
14165 if(connectWith && this.ready) { //Shouldn't be run the first time through due to massive slow-down
14166 for (i = connectWith.length - 1; i >= 0; i--){
14167 cur = $(connectWith[i], this.document[0]);
14168 for (j = cur.length - 1; j >= 0; j--){
14169 inst = $.data(cur[j], this.widgetFullName);
14170 if(inst && inst !== this && !inst.options.disabled) {
14171 queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element[0], event, { item: this.currentItem }) : $(inst.options.items, inst.element), inst]);
14172 this.containers.push(inst);
14173 }
14174 }
14175 }
14176 }
14177
14178 for (i = queries.length - 1; i >= 0; i--) {
14179 targetData = queries[i][1];
14180 _queries = queries[i][0];
14181
14182 for (j=0, queriesLength = _queries.length; j < queriesLength; j++) {
14183 item = $(_queries[j]);
14184
14185 item.data(this.widgetName + "-item", targetData); // Data for target checking (mouse manager)
14186
14187 items.push({
14188 item: item,
14189 instance: targetData,
14190 width: 0, height: 0,
14191 left: 0, top: 0
14192 });
14193 }
14194 }
14195
14196 },
14197
14198 refreshPositions: function(fast) {
14199
14200 // Determine whether items are being displayed horizontally
14201 this.floating = this.items.length ?
14202 this.options.axis === "x" || this._isFloating( this.items[ 0 ].item ) :
14203 false;
14204
14205 //This has to be redone because due to the item being moved out/into the offsetParent, the offsetParent's position will change
14206 if(this.offsetParent && this.helper) {
14207 this.offset.parent = this._getParentOffset();
14208 }
14209
14210 var i, item, t, p;
14211
14212 for (i = this.items.length - 1; i >= 0; i--){
14213 item = this.items[i];
14214
14215 //We ignore calculating positions of all connected containers when we're not over them
14216 if(item.instance !== this.currentContainer && this.currentContainer && item.item[0] !== this.currentItem[0]) {
14217 continue;
14218 }
14219
14220 t = this.options.toleranceElement ? $(this.options.toleranceElement, item.item) : item.item;
14221
14222 if (!fast) {
14223 item.width = t.outerWidth();
14224 item.height = t.outerHeight();
14225 }
14226
14227 p = t.offset();
14228 item.left = p.left;
14229 item.top = p.top;
14230 }
14231
14232 if(this.options.custom && this.options.custom.refreshContainers) {
14233 this.options.custom.refreshContainers.call(this);
14234 } else {
14235 for (i = this.containers.length - 1; i >= 0; i--){
14236 p = this.containers[i].element.offset();
14237 this.containers[i].containerCache.left = p.left;
14238 this.containers[i].containerCache.top = p.top;
14239 this.containers[i].containerCache.width = this.containers[i].element.outerWidth();
14240 this.containers[i].containerCache.height = this.containers[i].element.outerHeight();
14241 }
14242 }
14243
14244 return this;
14245 },
14246
14247 _createPlaceholder: function(that) {
14248 that = that || this;
14249 var className,
14250 o = that.options;
14251
14252 if(!o.placeholder || o.placeholder.constructor === String) {
14253 className = o.placeholder;
14254 o.placeholder = {
14255 element: function() {
14256
14257 var nodeName = that.currentItem[0].nodeName.toLowerCase(),
14258 element = $( "<" + nodeName + ">", that.document[0] )
14259 .addClass(className || that.currentItem[0].className+" ui-sortable-placeholder")
14260 .removeClass("ui-sortable-helper");
14261
14262 if ( nodeName === "tbody" ) {
14263 that._createTrPlaceholder(
14264 that.currentItem.find( "tr" ).eq( 0 ),
14265 $( "<tr>", that.document[ 0 ] ).appendTo( element )
14266 );
14267 } else if ( nodeName === "tr" ) {
14268 that._createTrPlaceholder( that.currentItem, element );
14269 } else if ( nodeName === "img" ) {
14270 element.attr( "src", that.currentItem.attr( "src" ) );
14271 }
14272
14273 if ( !className ) {
14274 element.css( "visibility", "hidden" );
14275 }
14276
14277 return element;
14278 },
14279 update: function(container, p) {
14280
14281 // 1. If a className is set as 'placeholder option, we don't force sizes - the class is responsible for that
14282 // 2. The option 'forcePlaceholderSize can be enabled to force it even if a class name is specified
14283 if(className && !o.forcePlaceholderSize) {
14284 return;
14285 }
14286
14287 //If the element doesn't have a actual height by itself (without styles coming from a stylesheet), it receives the inline height from the dragged item
14288 if(!p.height()) { p.height(that.currentItem.innerHeight() - parseInt(that.currentItem.css("paddingTop")||0, 10) - parseInt(that.currentItem.css("paddingBottom")||0, 10)); }
14289 if(!p.width()) { p.width(that.currentItem.innerWidth() - parseInt(that.currentItem.css("paddingLeft")||0, 10) - parseInt(that.currentItem.css("paddingRight")||0, 10)); }
14290 }
14291 };
14292 }
14293
14294 //Create the placeholder
14295 that.placeholder = $(o.placeholder.element.call(that.element, that.currentItem));
14296
14297 //Append it after the actual current item
14298 that.currentItem.after(that.placeholder);
14299
14300 //Update the size of the placeholder (TODO: Logic to fuzzy, see line 316/317)
14301 o.placeholder.update(that, that.placeholder);
14302
14303 },
14304
14305 _createTrPlaceholder: function( sourceTr, targetTr ) {
14306 var that = this;
14307
14308 sourceTr.children().each(function() {
14309 $( "<td> </td>", that.document[ 0 ] )
14310 .attr( "colspan", $( this ).attr( "colspan" ) || 1 )
14311 .appendTo( targetTr );
14312 });
14313 },
14314
14315 _contactContainers: function(event) {
14316 var i, j, dist, itemWithLeastDistance, posProperty, sizeProperty, cur, nearBottom, floating, axis,
14317 innermostContainer = null,
14318 innermostIndex = null;
14319
14320 // get innermost container that intersects with item
14321 for (i = this.containers.length - 1; i >= 0; i--) {
14322
14323 // never consider a container that's located within the item itself
14324 if($.contains(this.currentItem[0], this.containers[i].element[0])) {
14325 continue;
14326 }
14327
14328 if(this._intersectsWith(this.containers[i].containerCache)) {
14329
14330 // if we've already found a container and it's more "inner" than this, then continue
14331 if(innermostContainer && $.contains(this.containers[i].element[0], innermostContainer.element[0])) {
14332 continue;
14333 }
14334
14335 innermostContainer = this.containers[i];
14336 innermostIndex = i;
14337
14338 } else {
14339 // container doesn't intersect. trigger "out" event if necessary
14340 if(this.containers[i].containerCache.over) {
14341 this.containers[i]._trigger("out", event, this._uiHash(this));
14342 this.containers[i].containerCache.over = 0;
14343 }
14344 }
14345
14346 }
14347
14348 // if no intersecting containers found, return
14349 if(!innermostContainer) {
14350 return;
14351 }
14352
14353 // move the item into the container if it's not there already
14354 if(this.containers.length === 1) {
14355 if (!this.containers[innermostIndex].containerCache.over) {
14356 this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
14357 this.containers[innermostIndex].containerCache.over = 1;
14358 }
14359 } else {
14360
14361 //When entering a new container, we will find the item with the least distance and append our item near it
14362 dist = 10000;
14363 itemWithLeastDistance = null;
14364 floating = innermostContainer.floating || this._isFloating(this.currentItem);
14365 posProperty = floating ? "left" : "top";
14366 sizeProperty = floating ? "width" : "height";
14367 axis = floating ? "clientX" : "clientY";
14368
14369 for (j = this.items.length - 1; j >= 0; j--) {
14370 if(!$.contains(this.containers[innermostIndex].element[0], this.items[j].item[0])) {
14371 continue;
14372 }
14373 if(this.items[j].item[0] === this.currentItem[0]) {
14374 continue;
14375 }
14376
14377 cur = this.items[j].item.offset()[posProperty];
14378 nearBottom = false;
14379 if ( event[ axis ] - cur > this.items[ j ][ sizeProperty ] / 2 ) {
14380 nearBottom = true;
14381 }
14382
14383 if ( Math.abs( event[ axis ] - cur ) < dist ) {
14384 dist = Math.abs( event[ axis ] - cur );
14385 itemWithLeastDistance = this.items[ j ];
14386 this.direction = nearBottom ? "up": "down";
14387 }
14388 }
14389
14390 //Check if dropOnEmpty is enabled
14391 if(!itemWithLeastDistance && !this.options.dropOnEmpty) {
14392 return;
14393 }
14394
14395 if(this.currentContainer === this.containers[innermostIndex]) {
14396 if ( !this.currentContainer.containerCache.over ) {
14397 this.containers[ innermostIndex ]._trigger( "over", event, this._uiHash() );
14398 this.currentContainer.containerCache.over = 1;
14399 }
14400 return;
14401 }
14402
14403 itemWithLeastDistance ? this._rearrange(event, itemWithLeastDistance, null, true) : this._rearrange(event, null, this.containers[innermostIndex].element, true);
14404 this._trigger("change", event, this._uiHash());
14405 this.containers[innermostIndex]._trigger("change", event, this._uiHash(this));
14406 this.currentContainer = this.containers[innermostIndex];
14407
14408 //Update the placeholder
14409 this.options.placeholder.update(this.currentContainer, this.placeholder);
14410
14411 this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
14412 this.containers[innermostIndex].containerCache.over = 1;
14413 }
14414
14415
14416 },
14417
14418 _createHelper: function(event) {
14419
14420 var o = this.options,
14421 helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event, this.currentItem])) : (o.helper === "clone" ? this.currentItem.clone() : this.currentItem);
14422
14423 //Add the helper to the DOM if that didn't happen already
14424 if(!helper.parents("body").length) {
14425 $(o.appendTo !== "parent" ? o.appendTo : this.currentItem[0].parentNode)[0].appendChild(helper[0]);
14426 }
14427
14428 if(helper[0] === this.currentItem[0]) {
14429 this._storedCSS = { width: this.currentItem[0].style.width, height: this.currentItem[0].style.height, position: this.currentItem.css("position"), top: this.currentItem.css("top"), left: this.currentItem.css("left") };
14430 }
14431
14432 if(!helper[0].style.width || o.forceHelperSize) {
14433 helper.width(this.currentItem.width());
14434 }
14435 if(!helper[0].style.height || o.forceHelperSize) {
14436 helper.height(this.currentItem.height());
14437 }
14438
14439 return helper;
14440
14441 },
14442
14443 _adjustOffsetFromHelper: function(obj) {
14444 if (typeof obj === "string") {
14445 obj = obj.split(" ");
14446 }
14447 if ($.isArray(obj)) {
14448 obj = {left: +obj[0], top: +obj[1] || 0};
14449 }
14450 if ("left" in obj) {
14451 this.offset.click.left = obj.left + this.margins.left;
14452 }
14453 if ("right" in obj) {
14454 this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
14455 }
14456 if ("top" in obj) {
14457 this.offset.click.top = obj.top + this.margins.top;
14458 }
14459 if ("bottom" in obj) {
14460 this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
14461 }
14462 },
14463
14464 _getParentOffset: function() {
14465
14466
14467 //Get the offsetParent and cache its position
14468 this.offsetParent = this.helper.offsetParent();
14469 var po = this.offsetParent.offset();
14470
14471 // This is a special case where we need to modify a offset calculated on start, since the following happened:
14472 // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
14473 // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
14474 // the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
14475 if(this.cssPosition === "absolute" && this.scrollParent[0] !== this.document[0] && $.contains(this.scrollParent[0], this.offsetParent[0])) {
14476 po.left += this.scrollParent.scrollLeft();
14477 po.top += this.scrollParent.scrollTop();
14478 }
14479
14480 // This needs to be actually done for all browsers, since pageX/pageY includes this information
14481 // with an ugly IE fix
14482 if( this.offsetParent[0] === this.document[0].body || (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() === "html" && $.ui.ie)) {
14483 po = { top: 0, left: 0 };
14484 }
14485
14486 return {
14487 top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
14488 left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
14489 };
14490
14491 },
14492
14493 _getRelativeOffset: function() {
14494
14495 if(this.cssPosition === "relative") {
14496 var p = this.currentItem.position();
14497 return {
14498 top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
14499 left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
14500 };
14501 } else {
14502 return { top: 0, left: 0 };
14503 }
14504
14505 },
14506
14507 _cacheMargins: function() {
14508 this.margins = {
14509 left: (parseInt(this.currentItem.css("marginLeft"),10) || 0),
14510 top: (parseInt(this.currentItem.css("marginTop"),10) || 0)
14511 };
14512 },
14513
14514 _cacheHelperProportions: function() {
14515 this.helperProportions = {
14516 width: this.helper.outerWidth(),
14517 height: this.helper.outerHeight()
14518 };
14519 },
14520
14521 _setContainment: function() {
14522
14523 var ce, co, over,
14524 o = this.options;
14525 if(o.containment === "parent") {
14526 o.containment = this.helper[0].parentNode;
14527 }
14528 if(o.containment === "document" || o.containment === "window") {
14529 this.containment = [
14530 0 - this.offset.relative.left - this.offset.parent.left,
14531 0 - this.offset.relative.top - this.offset.parent.top,
14532 o.containment === "document" ? this.document.width() : this.window.width() - this.helperProportions.width - this.margins.left,
14533 (o.containment === "document" ? this.document.width() : this.window.height() || this.document[0].body.parentNode.scrollHeight) - this.helperProportions.height - this.margins.top
14534 ];
14535 }
14536
14537 if(!(/^(document|window|parent)$/).test(o.containment)) {
14538 ce = $(o.containment)[0];
14539 co = $(o.containment).offset();
14540 over = ($(ce).css("overflow") !== "hidden");
14541
14542 this.containment = [
14543 co.left + (parseInt($(ce).css("borderLeftWidth"),10) || 0) + (parseInt($(ce).css("paddingLeft"),10) || 0) - this.margins.left,
14544 co.top + (parseInt($(ce).css("borderTopWidth"),10) || 0) + (parseInt($(ce).css("paddingTop"),10) || 0) - this.margins.top,
14545 co.left+(over ? Math.max(ce.scrollWidth,ce.offsetWidth) : ce.offsetWidth) - (parseInt($(ce).css("borderLeftWidth"),10) || 0) - (parseInt($(ce).css("paddingRight"),10) || 0) - this.helperProportions.width - this.margins.left,
14546 co.top+(over ? Math.max(ce.scrollHeight,ce.offsetHeight) : ce.offsetHeight) - (parseInt($(ce).css("borderTopWidth"),10) || 0) - (parseInt($(ce).css("paddingBottom"),10) || 0) - this.helperProportions.height - this.margins.top
14547 ];
14548 }
14549
14550 },
14551
14552 _convertPositionTo: function(d, pos) {
14553
14554 if(!pos) {
14555 pos = this.position;
14556 }
14557 var mod = d === "absolute" ? 1 : -1,
14558 scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== this.document[0] && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent,
14559 scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
14560
14561 return {
14562 top: (
14563 pos.top + // The absolute mouse position
14564 this.offset.relative.top * mod + // Only for relative positioned nodes: Relative offset from element to offset parent
14565 this.offset.parent.top * mod - // The offsetParent's offset without borders (offset + border)
14566 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * mod)
14567 ),
14568 left: (
14569 pos.left + // The absolute mouse position
14570 this.offset.relative.left * mod + // Only for relative positioned nodes: Relative offset from element to offset parent
14571 this.offset.parent.left * mod - // The offsetParent's offset without borders (offset + border)
14572 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ) * mod)
14573 )
14574 };
14575
14576 },
14577
14578 _generatePosition: function(event) {
14579
14580 var top, left,
14581 o = this.options,
14582 pageX = event.pageX,
14583 pageY = event.pageY,
14584 scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== this.document[0] && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
14585
14586 // This is another very weird special case that only happens for relative elements:
14587 // 1. If the css position is relative
14588 // 2. and the scroll parent is the document or similar to the offset parent
14589 // we have to refresh the relative offset during the scroll so there are no jumps
14590 if(this.cssPosition === "relative" && !(this.scrollParent[0] !== this.document[0] && this.scrollParent[0] !== this.offsetParent[0])) {
14591 this.offset.relative = this._getRelativeOffset();
14592 }
14593
14594 /*
14595 * - Position constraining -
14596 * Constrain the position to a mix of grid, containment.
14597 */
14598
14599 if(this.originalPosition) { //If we are not dragging yet, we won't check for options
14600
14601 if(this.containment) {
14602 if(event.pageX - this.offset.click.left < this.containment[0]) {
14603 pageX = this.containment[0] + this.offset.click.left;
14604 }
14605 if(event.pageY - this.offset.click.top < this.containment[1]) {
14606 pageY = this.containment[1] + this.offset.click.top;
14607 }
14608 if(event.pageX - this.offset.click.left > this.containment[2]) {
14609 pageX = this.containment[2] + this.offset.click.left;
14610 }
14611 if(event.pageY - this.offset.click.top > this.containment[3]) {
14612 pageY = this.containment[3] + this.offset.click.top;
14613 }
14614 }
14615
14616 if(o.grid) {
14617 top = this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1];
14618 pageY = this.containment ? ( (top - this.offset.click.top >= this.containment[1] && top - this.offset.click.top <= this.containment[3]) ? top : ((top - this.offset.click.top >= this.containment[1]) ? top - o.grid[1] : top + o.grid[1])) : top;
14619
14620 left = this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0];
14621 pageX = this.containment ? ( (left - this.offset.click.left >= this.containment[0] && left - this.offset.click.left <= this.containment[2]) ? left : ((left - this.offset.click.left >= this.containment[0]) ? left - o.grid[0] : left + o.grid[0])) : left;
14622 }
14623
14624 }
14625
14626 return {
14627 top: (
14628 pageY - // The absolute mouse position
14629 this.offset.click.top - // Click offset (relative to the element)
14630 this.offset.relative.top - // Only for relative positioned nodes: Relative offset from element to offset parent
14631 this.offset.parent.top + // The offsetParent's offset without borders (offset + border)
14632 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ))
14633 ),
14634 left: (
14635 pageX - // The absolute mouse position
14636 this.offset.click.left - // Click offset (relative to the element)
14637 this.offset.relative.left - // Only for relative positioned nodes: Relative offset from element to offset parent
14638 this.offset.parent.left + // The offsetParent's offset without borders (offset + border)
14639 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ))
14640 )
14641 };
14642
14643 },
14644
14645 _rearrange: function(event, i, a, hardRefresh) {
14646
14647 a ? a[0].appendChild(this.placeholder[0]) : i.item[0].parentNode.insertBefore(this.placeholder[0], (this.direction === "down" ? i.item[0] : i.item[0].nextSibling));
14648
14649 //Various things done here to improve the performance:
14650 // 1. we create a setTimeout, that calls refreshPositions
14651 // 2. on the instance, we have a counter variable, that get's higher after every append
14652 // 3. on the local scope, we copy the counter variable, and check in the timeout, if it's still the same
14653 // 4. this lets only the last addition to the timeout stack through
14654 this.counter = this.counter ? ++this.counter : 1;
14655 var counter = this.counter;
14656
14657 this._delay(function() {
14658 if(counter === this.counter) {
14659 this.refreshPositions(!hardRefresh); //Precompute after each DOM insertion, NOT on mousemove
14660 }
14661 });
14662
14663 },
14664
14665 _clear: function(event, noPropagation) {
14666
14667 this.reverting = false;
14668 // We delay all events that have to be triggered to after the point where the placeholder has been removed and
14669 // everything else normalized again
14670 var i,
14671 delayedTriggers = [];
14672
14673 // We first have to update the dom position of the actual currentItem
14674 // Note: don't do it if the current item is already removed (by a user), or it gets reappended (see #4088)
14675 if(!this._noFinalSort && this.currentItem.parent().length) {
14676 this.placeholder.before(this.currentItem);
14677 }
14678 this._noFinalSort = null;
14679
14680 if(this.helper[0] === this.currentItem[0]) {
14681 for(i in this._storedCSS) {
14682 if(this._storedCSS[i] === "auto" || this._storedCSS[i] === "static") {
14683 this._storedCSS[i] = "";
14684 }
14685 }
14686 this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
14687 } else {
14688 this.currentItem.show();
14689 }
14690
14691 if(this.fromOutside && !noPropagation) {
14692 delayedTriggers.push(function(event) { this._trigger("receive", event, this._uiHash(this.fromOutside)); });
14693 }
14694 if((this.fromOutside || this.domPosition.prev !== this.currentItem.prev().not(".ui-sortable-helper")[0] || this.domPosition.parent !== this.currentItem.parent()[0]) && !noPropagation) {
14695 delayedTriggers.push(function(event) { this._trigger("update", event, this._uiHash()); }); //Trigger update callback if the DOM position has changed
14696 }
14697
14698 // Check if the items Container has Changed and trigger appropriate
14699 // events.
14700 if (this !== this.currentContainer) {
14701 if(!noPropagation) {
14702 delayedTriggers.push(function(event) { this._trigger("remove", event, this._uiHash()); });
14703 delayedTriggers.push((function(c) { return function(event) { c._trigger("receive", event, this._uiHash(this)); }; }).call(this, this.currentContainer));
14704 delayedTriggers.push((function(c) { return function(event) { c._trigger("update", event, this._uiHash(this)); }; }).call(this, this.currentContainer));
14705 }
14706 }
14707
14708
14709 //Post events to containers
14710 function delayEvent( type, instance, container ) {
14711 return function( event ) {
14712 container._trigger( type, event, instance._uiHash( instance ) );
14713 };
14714 }
14715 for (i = this.containers.length - 1; i >= 0; i--){
14716 if (!noPropagation) {
14717 delayedTriggers.push( delayEvent( "deactivate", this, this.containers[ i ] ) );
14718 }
14719 if(this.containers[i].containerCache.over) {
14720 delayedTriggers.push( delayEvent( "out", this, this.containers[ i ] ) );
14721 this.containers[i].containerCache.over = 0;
14722 }
14723 }
14724
14725 //Do what was originally in plugins
14726 if ( this.storedCursor ) {
14727 this.document.find( "body" ).css( "cursor", this.storedCursor );
14728 this.storedStylesheet.remove();
14729 }
14730 if(this._storedOpacity) {
14731 this.helper.css("opacity", this._storedOpacity);
14732 }
14733 if(this._storedZIndex) {
14734 this.helper.css("zIndex", this._storedZIndex === "auto" ? "" : this._storedZIndex);
14735 }
14736
14737 this.dragging = false;
14738
14739 if(!noPropagation) {
14740 this._trigger("beforeStop", event, this._uiHash());
14741 }
14742
14743 //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
14744 this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
14745
14746 if ( !this.cancelHelperRemoval ) {
14747 if ( this.helper[ 0 ] !== this.currentItem[ 0 ] ) {
14748 this.helper.remove();
14749 }
14750 this.helper = null;
14751 }
14752
14753 if(!noPropagation) {
14754 for (i=0; i < delayedTriggers.length; i++) {
14755 delayedTriggers[i].call(this, event);
14756 } //Trigger all delayed events
14757 this._trigger("stop", event, this._uiHash());
14758 }
14759
14760 this.fromOutside = false;
14761 return !this.cancelHelperRemoval;
14762
14763 },
14764
14765 _trigger: function() {
14766 if ($.Widget.prototype._trigger.apply(this, arguments) === false) {
14767 this.cancel();
14768 }
14769 },
14770
14771 _uiHash: function(_inst) {
14772 var inst = _inst || this;
14773 return {
14774 helper: inst.helper,
14775 placeholder: inst.placeholder || $([]),
14776 position: inst.position,
14777 originalPosition: inst.originalPosition,
14778 offset: inst.positionAbs,
14779 item: inst.currentItem,
14780 sender: _inst ? _inst.element : null
14781 };
14782 }
14783
14784 });
14785
14786
14787 /*!
14788 * jQuery UI Spinner 1.11.4
14789 * http://jqueryui.com
14790 *
14791 * Copyright jQuery Foundation and other contributors
14792 * Released under the MIT license.
14793 * http://jquery.org/license
14794 *
14795 * http://api.jqueryui.com/spinner/
14796 */
14797
14798
14799 function spinner_modifier( fn ) {
14800 return function() {
14801 var previous = this.element.val();
14802 fn.apply( this, arguments );
14803 this._refresh();
14804 if ( previous !== this.element.val() ) {
14805 this._trigger( "change" );
14806 }
14807 };
14808 }
14809
14810 var spinner = $.widget( "ui.spinner", {
14811 version: "1.11.4",
14812 defaultElement: "<input>",
14813 widgetEventPrefix: "spin",
14814 options: {
14815 culture: null,
14816 icons: {
14817 down: "ui-icon-triangle-1-s",
14818 up: "ui-icon-triangle-1-n"
14819 },
14820 incremental: true,
14821 max: null,
14822 min: null,
14823 numberFormat: null,
14824 page: 10,
14825 step: 1,
14826
14827 change: null,
14828 spin: null,
14829 start: null,
14830 stop: null
14831 },
14832
14833 _create: function() {
14834 // handle string values that need to be parsed
14835 this._setOption( "max", this.options.max );
14836 this._setOption( "min", this.options.min );
14837 this._setOption( "step", this.options.step );
14838
14839 // Only format if there is a value, prevents the field from being marked
14840 // as invalid in Firefox, see #9573.
14841 if ( this.value() !== "" ) {
14842 // Format the value, but don't constrain.
14843 this._value( this.element.val(), true );
14844 }
14845
14846 this._draw();
14847 this._on( this._events );
14848 this._refresh();
14849
14850 // turning off autocomplete prevents the browser from remembering the
14851 // value when navigating through history, so we re-enable autocomplete
14852 // if the page is unloaded before the widget is destroyed. #7790
14853 this._on( this.window, {
14854 beforeunload: function() {
14855 this.element.removeAttr( "autocomplete" );
14856 }
14857 });
14858 },
14859
14860 _getCreateOptions: function() {
14861 var options = {},
14862 element = this.element;
14863
14864 $.each( [ "min", "max", "step" ], function( i, option ) {
14865 var value = element.attr( option );
14866 if ( value !== undefined && value.length ) {
14867 options[ option ] = value;
14868 }
14869 });
14870
14871 return options;
14872 },
14873
14874 _events: {
14875 keydown: function( event ) {
14876 if ( this._start( event ) && this._keydown( event ) ) {
14877 event.preventDefault();
14878 }
14879 },
14880 keyup: "_stop",
14881 focus: function() {
14882 this.previous = this.element.val();
14883 },
14884 blur: function( event ) {
14885 if ( this.cancelBlur ) {
14886 delete this.cancelBlur;
14887 return;
14888 }
14889
14890 this._stop();
14891 this._refresh();
14892 if ( this.previous !== this.element.val() ) {
14893 this._trigger( "change", event );
14894 }
14895 },
14896 mousewheel: function( event, delta ) {
14897 if ( !delta ) {
14898 return;
14899 }
14900 if ( !this.spinning && !this._start( event ) ) {
14901 return false;
14902 }
14903
14904 this._spin( (delta > 0 ? 1 : -1) * this.options.step, event );
14905 clearTimeout( this.mousewheelTimer );
14906 this.mousewheelTimer = this._delay(function() {
14907 if ( this.spinning ) {
14908 this._stop( event );
14909 }
14910 }, 100 );
14911 event.preventDefault();
14912 },
14913 "mousedown .ui-spinner-button": function( event ) {
14914 var previous;
14915
14916 // We never want the buttons to have focus; whenever the user is
14917 // interacting with the spinner, the focus should be on the input.
14918 // If the input is focused then this.previous is properly set from
14919 // when the input first received focus. If the input is not focused
14920 // then we need to set this.previous based on the value before spinning.
14921 previous = this.element[0] === this.document[0].activeElement ?
14922 this.previous : this.element.val();
14923 function checkFocus() {
14924 var isActive = this.element[0] === this.document[0].activeElement;
14925 if ( !isActive ) {
14926 this.element.focus();
14927 this.previous = previous;
14928 // support: IE
14929 // IE sets focus asynchronously, so we need to check if focus
14930 // moved off of the input because the user clicked on the button.
14931 this._delay(function() {
14932 this.previous = previous;
14933 });
14934 }
14935 }
14936
14937 // ensure focus is on (or stays on) the text field
14938 event.preventDefault();
14939 checkFocus.call( this );
14940
14941 // support: IE
14942 // IE doesn't prevent moving focus even with event.preventDefault()
14943 // so we set a flag to know when we should ignore the blur event
14944 // and check (again) if focus moved off of the input.
14945 this.cancelBlur = true;
14946 this._delay(function() {
14947 delete this.cancelBlur;
14948 checkFocus.call( this );
14949 });
14950
14951 if ( this._start( event ) === false ) {
14952 return;
14953 }
14954
14955 this._repeat( null, $( event.currentTarget ).hasClass( "ui-spinner-up" ) ? 1 : -1, event );
14956 },
14957 "mouseup .ui-spinner-button": "_stop",
14958 "mouseenter .ui-spinner-button": function( event ) {
14959 // button will add ui-state-active if mouse was down while mouseleave and kept down
14960 if ( !$( event.currentTarget ).hasClass( "ui-state-active" ) ) {
14961 return;
14962 }
14963
14964 if ( this._start( event ) === false ) {
14965 return false;
14966 }
14967 this._repeat( null, $( event.currentTarget ).hasClass( "ui-spinner-up" ) ? 1 : -1, event );
14968 },
14969 // TODO: do we really want to consider this a stop?
14970 // shouldn't we just stop the repeater and wait until mouseup before
14971 // we trigger the stop event?
14972 "mouseleave .ui-spinner-button": "_stop"
14973 },
14974
14975 _draw: function() {
14976 var uiSpinner = this.uiSpinner = this.element
14977 .addClass( "ui-spinner-input" )
14978 .attr( "autocomplete", "off" )
14979 .wrap( this._uiSpinnerHtml() )
14980 .parent()
14981 // add buttons
14982 .append( this._buttonHtml() );
14983
14984 this.element.attr( "role", "spinbutton" );
14985
14986 // button bindings
14987 this.buttons = uiSpinner.find( ".ui-spinner-button" )
14988 .attr( "tabIndex", -1 )
14989 .button()
14990 .removeClass( "ui-corner-all" );
14991
14992 // IE 6 doesn't understand height: 50% for the buttons
14993 // unless the wrapper has an explicit height
14994 if ( this.buttons.height() > Math.ceil( uiSpinner.height() * 0.5 ) &&
14995 uiSpinner.height() > 0 ) {
14996 uiSpinner.height( uiSpinner.height() );
14997 }
14998
14999 // disable spinner if element was already disabled
15000 if ( this.options.disabled ) {
15001 this.disable();
15002 }
15003 },
15004
15005 _keydown: function( event ) {
15006 var options = this.options,
15007 keyCode = $.ui.keyCode;
15008
15009 switch ( event.keyCode ) {
15010 case keyCode.UP:
15011 this._repeat( null, 1, event );
15012 return true;
15013 case keyCode.DOWN:
15014 this._repeat( null, -1, event );
15015 return true;
15016 case keyCode.PAGE_UP:
15017 this._repeat( null, options.page, event );
15018 return true;
15019 case keyCode.PAGE_DOWN:
15020 this._repeat( null, -options.page, event );
15021 return true;
15022 }
15023
15024 return false;
15025 },
15026
15027 _uiSpinnerHtml: function() {
15028 return "<span class='ui-spinner ui-widget ui-widget-content ui-corner-all'></span>";
15029 },
15030
15031 _buttonHtml: function() {
15032 return "" +
15033 "<a class='ui-spinner-button ui-spinner-up ui-corner-tr'>" +
15034 "<span class='ui-icon " + this.options.icons.up + "'>▲</span>" +
15035 "</a>" +
15036 "<a class='ui-spinner-button ui-spinner-down ui-corner-br'>" +
15037 "<span class='ui-icon " + this.options.icons.down + "'>▼</span>" +
15038 "</a>";
15039 },
15040
15041 _start: function( event ) {
15042 if ( !this.spinning && this._trigger( "start", event ) === false ) {
15043 return false;
15044 }
15045
15046 if ( !this.counter ) {
15047 this.counter = 1;
15048 }
15049 this.spinning = true;
15050 return true;
15051 },
15052
15053 _repeat: function( i, steps, event ) {
15054 i = i || 500;
15055
15056 clearTimeout( this.timer );
15057 this.timer = this._delay(function() {
15058 this._repeat( 40, steps, event );
15059 }, i );
15060
15061 this._spin( steps * this.options.step, event );
15062 },
15063
15064 _spin: function( step, event ) {
15065 var value = this.value() || 0;
15066
15067 if ( !this.counter ) {
15068 this.counter = 1;
15069 }
15070
15071 value = this._adjustValue( value + step * this._increment( this.counter ) );
15072
15073 if ( !this.spinning || this._trigger( "spin", event, { value: value } ) !== false) {
15074 this._value( value );
15075 this.counter++;
15076 }
15077 },
15078
15079 _increment: function( i ) {
15080 var incremental = this.options.incremental;
15081
15082 if ( incremental ) {
15083 return $.isFunction( incremental ) ?
15084 incremental( i ) :
15085 Math.floor( i * i * i / 50000 - i * i / 500 + 17 * i / 200 + 1 );
15086 }
15087
15088 return 1;
15089 },
15090
15091 _precision: function() {
15092 var precision = this._precisionOf( this.options.step );
15093 if ( this.options.min !== null ) {
15094 precision = Math.max( precision, this._precisionOf( this.options.min ) );
15095 }
15096 return precision;
15097 },
15098
15099 _precisionOf: function( num ) {
15100 var str = num.toString(),
15101 decimal = str.indexOf( "." );
15102 return decimal === -1 ? 0 : str.length - decimal - 1;
15103 },
15104
15105 _adjustValue: function( value ) {
15106 var base, aboveMin,
15107 options = this.options;
15108
15109 // make sure we're at a valid step
15110 // - find out where we are relative to the base (min or 0)
15111 base = options.min !== null ? options.min : 0;
15112 aboveMin = value - base;
15113 // - round to the nearest step
15114 aboveMin = Math.round(aboveMin / options.step) * options.step;
15115 // - rounding is based on 0, so adjust back to our base
15116 value = base + aboveMin;
15117
15118 // fix precision from bad JS floating point math
15119 value = parseFloat( value.toFixed( this._precision() ) );
15120
15121 // clamp the value
15122 if ( options.max !== null && value > options.max) {
15123 return options.max;
15124 }
15125 if ( options.min !== null && value < options.min ) {
15126 return options.min;
15127 }
15128
15129 return value;
15130 },
15131
15132 _stop: function( event ) {
15133 if ( !this.spinning ) {
15134 return;
15135 }
15136
15137 clearTimeout( this.timer );
15138 clearTimeout( this.mousewheelTimer );
15139 this.counter = 0;
15140 this.spinning = false;
15141 this._trigger( "stop", event );
15142 },
15143
15144 _setOption: function( key, value ) {
15145 if ( key === "culture" || key === "numberFormat" ) {
15146 var prevValue = this._parse( this.element.val() );
15147 this.options[ key ] = value;
15148 this.element.val( this._format( prevValue ) );
15149 return;
15150 }
15151
15152 if ( key === "max" || key === "min" || key === "step" ) {
15153 if ( typeof value === "string" ) {
15154 value = this._parse( value );
15155 }
15156 }
15157 if ( key === "icons" ) {
15158 this.buttons.first().find( ".ui-icon" )
15159 .removeClass( this.options.icons.up )
15160 .addClass( value.up );
15161 this.buttons.last().find( ".ui-icon" )
15162 .removeClass( this.options.icons.down )
15163 .addClass( value.down );
15164 }
15165
15166 this._super( key, value );
15167
15168 if ( key === "disabled" ) {
15169 this.widget().toggleClass( "ui-state-disabled", !!value );
15170 this.element.prop( "disabled", !!value );
15171 this.buttons.button( value ? "disable" : "enable" );
15172 }
15173 },
15174
15175 _setOptions: spinner_modifier(function( options ) {
15176 this._super( options );
15177 }),
15178
15179 _parse: function( val ) {
15180 if ( typeof val === "string" && val !== "" ) {
15181 val = window.Globalize && this.options.numberFormat ?
15182 Globalize.parseFloat( val, 10, this.options.culture ) : +val;
15183 }
15184 return val === "" || isNaN( val ) ? null : val;
15185 },
15186
15187 _format: function( value ) {
15188 if ( value === "" ) {
15189 return "";
15190 }
15191 return window.Globalize && this.options.numberFormat ?
15192 Globalize.format( value, this.options.numberFormat, this.options.culture ) :
15193 value;
15194 },
15195
15196 _refresh: function() {
15197 this.element.attr({
15198 "aria-valuemin": this.options.min,
15199 "aria-valuemax": this.options.max,
15200 // TODO: what should we do with values that can't be parsed?
15201 "aria-valuenow": this._parse( this.element.val() )
15202 });
15203 },
15204
15205 isValid: function() {
15206 var value = this.value();
15207
15208 // null is invalid
15209 if ( value === null ) {
15210 return false;
15211 }
15212
15213 // if value gets adjusted, it's invalid
15214 return value === this._adjustValue( value );
15215 },
15216
15217 // update the value without triggering change
15218 _value: function( value, allowAny ) {
15219 var parsed;
15220 if ( value !== "" ) {
15221 parsed = this._parse( value );
15222 if ( parsed !== null ) {
15223 if ( !allowAny ) {
15224 parsed = this._adjustValue( parsed );
15225 }
15226 value = this._format( parsed );
15227 }
15228 }
15229 this.element.val( value );
15230 this._refresh();
15231 },
15232
15233 _destroy: function() {
15234 this.element
15235 .removeClass( "ui-spinner-input" )
15236 .prop( "disabled", false )
15237 .removeAttr( "autocomplete" )
15238 .removeAttr( "role" )
15239 .removeAttr( "aria-valuemin" )
15240 .removeAttr( "aria-valuemax" )
15241 .removeAttr( "aria-valuenow" );
15242 this.uiSpinner.replaceWith( this.element );
15243 },
15244
15245 stepUp: spinner_modifier(function( steps ) {
15246 this._stepUp( steps );
15247 }),
15248 _stepUp: function( steps ) {
15249 if ( this._start() ) {
15250 this._spin( (steps || 1) * this.options.step );
15251 this._stop();
15252 }
15253 },
15254
15255 stepDown: spinner_modifier(function( steps ) {
15256 this._stepDown( steps );
15257 }),
15258 _stepDown: function( steps ) {
15259 if ( this._start() ) {
15260 this._spin( (steps || 1) * -this.options.step );
15261 this._stop();
15262 }
15263 },
15264
15265 pageUp: spinner_modifier(function( pages ) {
15266 this._stepUp( (pages || 1) * this.options.page );
15267 }),
15268
15269 pageDown: spinner_modifier(function( pages ) {
15270 this._stepDown( (pages || 1) * this.options.page );
15271 }),
15272
15273 value: function( newVal ) {
15274 if ( !arguments.length ) {
15275 return this._parse( this.element.val() );
15276 }
15277 spinner_modifier( this._value ).call( this, newVal );
15278 },
15279
15280 widget: function() {
15281 return this.uiSpinner;
15282 }
15283 });
15284
15285
15286 /*!
15287 * jQuery UI Tabs 1.11.4
15288 * http://jqueryui.com
15289 *
15290 * Copyright jQuery Foundation and other contributors
15291 * Released under the MIT license.
15292 * http://jquery.org/license
15293 *
15294 * http://api.jqueryui.com/tabs/
15295 */
15296
15297
15298 var tabs = $.widget( "ui.tabs", {
15299 version: "1.11.4",
15300 delay: 300,
15301 options: {
15302 active: null,
15303 collapsible: false,
15304 event: "click",
15305 heightStyle: "content",
15306 hide: null,
15307 show: null,
15308
15309 // callbacks
15310 activate: null,
15311 beforeActivate: null,
15312 beforeLoad: null,
15313 load: null
15314 },
15315
15316 _isLocal: (function() {
15317 var rhash = /#.*$/;
15318
15319 return function( anchor ) {
15320 var anchorUrl, locationUrl;
15321
15322 // support: IE7
15323 // IE7 doesn't normalize the href property when set via script (#9317)
15324 anchor = anchor.cloneNode( false );
15325
15326 anchorUrl = anchor.href.replace( rhash, "" );
15327 locationUrl = location.href.replace( rhash, "" );
15328
15329 // decoding may throw an error if the URL isn't UTF-8 (#9518)
15330 try {
15331 anchorUrl = decodeURIComponent( anchorUrl );
15332 } catch ( error ) {}
15333 try {
15334 locationUrl = decodeURIComponent( locationUrl );
15335 } catch ( error ) {}
15336
15337 return anchor.hash.length > 1 && anchorUrl === locationUrl;
15338 };
15339 })(),
15340
15341 _create: function() {
15342 var that = this,
15343 options = this.options;
15344
15345 this.running = false;
15346
15347 this.element
15348 .addClass( "ui-tabs ui-widget ui-widget-content ui-corner-all" )
15349 .toggleClass( "ui-tabs-collapsible", options.collapsible );
15350
15351 this._processTabs();
15352 options.active = this._initialActive();
15353
15354 // Take disabling tabs via class attribute from HTML
15355 // into account and update option properly.
15356 if ( $.isArray( options.disabled ) ) {
15357 options.disabled = $.unique( options.disabled.concat(
15358 $.map( this.tabs.filter( ".ui-state-disabled" ), function( li ) {
15359 return that.tabs.index( li );
15360 })
15361 ) ).sort();
15362 }
15363
15364 // check for length avoids error when initializing empty list
15365 if ( this.options.active !== false && this.anchors.length ) {
15366 this.active = this._findActive( options.active );
15367 } else {
15368 this.active = $();
15369 }
15370
15371 this._refresh();
15372
15373 if ( this.active.length ) {
15374 this.load( options.active );
15375 }
15376 },
15377
15378 _initialActive: function() {
15379 var active = this.options.active,
15380 collapsible = this.options.collapsible,
15381 locationHash = location.hash.substring( 1 );
15382
15383 if ( active === null ) {
15384 // check the fragment identifier in the URL
15385 if ( locationHash ) {
15386 this.tabs.each(function( i, tab ) {
15387 if ( $( tab ).attr( "aria-controls" ) === locationHash ) {
15388 active = i;
15389 return false;
15390 }
15391 });
15392 }
15393
15394 // check for a tab marked active via a class
15395 if ( active === null ) {
15396 active = this.tabs.index( this.tabs.filter( ".ui-tabs-active" ) );
15397 }
15398
15399 // no active tab, set to false
15400 if ( active === null || active === -1 ) {
15401 active = this.tabs.length ? 0 : false;
15402 }
15403 }
15404
15405 // handle numbers: negative, out of range
15406 if ( active !== false ) {
15407 active = this.tabs.index( this.tabs.eq( active ) );
15408 if ( active === -1 ) {
15409 active = collapsible ? false : 0;
15410 }
15411 }
15412
15413 // don't allow collapsible: false and active: false
15414 if ( !collapsible && active === false && this.anchors.length ) {
15415 active = 0;
15416 }
15417
15418 return active;
15419 },
15420
15421 _getCreateEventData: function() {
15422 return {
15423 tab: this.active,
15424 panel: !this.active.length ? $() : this._getPanelForTab( this.active )
15425 };
15426 },
15427
15428 _tabKeydown: function( event ) {
15429 var focusedTab = $( this.document[0].activeElement ).closest( "li" ),
15430 selectedIndex = this.tabs.index( focusedTab ),
15431 goingForward = true;
15432
15433 if ( this._handlePageNav( event ) ) {
15434 return;
15435 }
15436
15437 switch ( event.keyCode ) {
15438 case $.ui.keyCode.RIGHT:
15439 case $.ui.keyCode.DOWN:
15440 selectedIndex++;
15441 break;
15442 case $.ui.keyCode.UP:
15443 case $.ui.keyCode.LEFT:
15444 goingForward = false;
15445 selectedIndex--;
15446 break;
15447 case $.ui.keyCode.END:
15448 selectedIndex = this.anchors.length - 1;
15449 break;
15450 case $.ui.keyCode.HOME:
15451 selectedIndex = 0;
15452 break;
15453 case $.ui.keyCode.SPACE:
15454 // Activate only, no collapsing
15455 event.preventDefault();
15456 clearTimeout( this.activating );
15457 this._activate( selectedIndex );
15458 return;
15459 case $.ui.keyCode.ENTER:
15460 // Toggle (cancel delayed activation, allow collapsing)
15461 event.preventDefault();
15462 clearTimeout( this.activating );
15463 // Determine if we should collapse or activate
15464 this._activate( selectedIndex === this.options.active ? false : selectedIndex );
15465 return;
15466 default:
15467 return;
15468 }
15469
15470 // Focus the appropriate tab, based on which key was pressed
15471 event.preventDefault();
15472 clearTimeout( this.activating );
15473 selectedIndex = this._focusNextTab( selectedIndex, goingForward );
15474
15475 // Navigating with control/command key will prevent automatic activation
15476 if ( !event.ctrlKey && !event.metaKey ) {
15477
15478 // Update aria-selected immediately so that AT think the tab is already selected.
15479 // Otherwise AT may confuse the user by stating that they need to activate the tab,
15480 // but the tab will already be activated by the time the announcement finishes.
15481 focusedTab.attr( "aria-selected", "false" );
15482 this.tabs.eq( selectedIndex ).attr( "aria-selected", "true" );
15483
15484 this.activating = this._delay(function() {
15485 this.option( "active", selectedIndex );
15486 }, this.delay );
15487 }
15488 },
15489
15490 _panelKeydown: function( event ) {
15491 if ( this._handlePageNav( event ) ) {
15492 return;
15493 }
15494
15495 // Ctrl+up moves focus to the current tab
15496 if ( event.ctrlKey && event.keyCode === $.ui.keyCode.UP ) {
15497 event.preventDefault();
15498 this.active.focus();
15499 }
15500 },
15501
15502 // Alt+page up/down moves focus to the previous/next tab (and activates)
15503 _handlePageNav: function( event ) {
15504 if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_UP ) {
15505 this._activate( this._focusNextTab( this.options.active - 1, false ) );
15506 return true;
15507 }
15508 if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_DOWN ) {
15509 this._activate( this._focusNextTab( this.options.active + 1, true ) );
15510 return true;
15511 }
15512 },
15513
15514 _findNextTab: function( index, goingForward ) {
15515 var lastTabIndex = this.tabs.length - 1;
15516
15517 function constrain() {
15518 if ( index > lastTabIndex ) {
15519 index = 0;
15520 }
15521 if ( index < 0 ) {
15522 index = lastTabIndex;
15523 }
15524 return index;
15525 }
15526
15527 while ( $.inArray( constrain(), this.options.disabled ) !== -1 ) {
15528 index = goingForward ? index + 1 : index - 1;
15529 }
15530
15531 return index;
15532 },
15533
15534 _focusNextTab: function( index, goingForward ) {
15535 index = this._findNextTab( index, goingForward );
15536 this.tabs.eq( index ).focus();
15537 return index;
15538 },
15539
15540 _setOption: function( key, value ) {
15541 if ( key === "active" ) {
15542 // _activate() will handle invalid values and update this.options
15543 this._activate( value );
15544 return;
15545 }
15546
15547 if ( key === "disabled" ) {
15548 // don't use the widget factory's disabled handling
15549 this._setupDisabled( value );
15550 return;
15551 }
15552
15553 this._super( key, value);
15554
15555 if ( key === "collapsible" ) {
15556 this.element.toggleClass( "ui-tabs-collapsible", value );
15557 // Setting collapsible: false while collapsed; open first panel
15558 if ( !value && this.options.active === false ) {
15559 this._activate( 0 );
15560 }
15561 }
15562
15563 if ( key === "event" ) {
15564 this._setupEvents( value );
15565 }
15566
15567 if ( key === "heightStyle" ) {
15568 this._setupHeightStyle( value );
15569 }
15570 },
15571
15572 _sanitizeSelector: function( hash ) {
15573 return hash ? hash.replace( /[!"$%&'()*+,.\/:;<=>?@\[\]\^`{|}~]/g, "\\$&" ) : "";
15574 },
15575
15576 refresh: function() {
15577 var options = this.options,
15578 lis = this.tablist.children( ":has(a[href])" );
15579
15580 // get disabled tabs from class attribute from HTML
15581 // this will get converted to a boolean if needed in _refresh()
15582 options.disabled = $.map( lis.filter( ".ui-state-disabled" ), function( tab ) {
15583 return lis.index( tab );
15584 });
15585
15586 this._processTabs();
15587
15588 // was collapsed or no tabs
15589 if ( options.active === false || !this.anchors.length ) {
15590 options.active = false;
15591 this.active = $();
15592 // was active, but active tab is gone
15593 } else if ( this.active.length && !$.contains( this.tablist[ 0 ], this.active[ 0 ] ) ) {
15594 // all remaining tabs are disabled
15595 if ( this.tabs.length === options.disabled.length ) {
15596 options.active = false;
15597 this.active = $();
15598 // activate previous tab
15599 } else {
15600 this._activate( this._findNextTab( Math.max( 0, options.active - 1 ), false ) );
15601 }
15602 // was active, active tab still exists
15603 } else {
15604 // make sure active index is correct
15605 options.active = this.tabs.index( this.active );
15606 }
15607
15608 this._refresh();
15609 },
15610
15611 _refresh: function() {
15612 this._setupDisabled( this.options.disabled );
15613 this._setupEvents( this.options.event );
15614 this._setupHeightStyle( this.options.heightStyle );
15615
15616 this.tabs.not( this.active ).attr({
15617 "aria-selected": "false",
15618 "aria-expanded": "false",
15619 tabIndex: -1
15620 });
15621 this.panels.not( this._getPanelForTab( this.active ) )
15622 .hide()
15623 .attr({
15624 "aria-hidden": "true"
15625 });
15626
15627 // Make sure one tab is in the tab order
15628 if ( !this.active.length ) {
15629 this.tabs.eq( 0 ).attr( "tabIndex", 0 );
15630 } else {
15631 this.active
15632 .addClass( "ui-tabs-active ui-state-active" )
15633 .attr({
15634 "aria-selected": "true",
15635 "aria-expanded": "true",
15636 tabIndex: 0
15637 });
15638 this._getPanelForTab( this.active )
15639 .show()
15640 .attr({
15641 "aria-hidden": "false"
15642 });
15643 }
15644 },
15645
15646 _processTabs: function() {
15647 var that = this,
15648 prevTabs = this.tabs,
15649 prevAnchors = this.anchors,
15650 prevPanels = this.panels;
15651
15652 this.tablist = this._getList()
15653 .addClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
15654 .attr( "role", "tablist" )
15655
15656 // Prevent users from focusing disabled tabs via click
15657 .delegate( "> li", "mousedown" + this.eventNamespace, function( event ) {
15658 if ( $( this ).is( ".ui-state-disabled" ) ) {
15659 event.preventDefault();
15660 }
15661 })
15662
15663 // support: IE <9
15664 // Preventing the default action in mousedown doesn't prevent IE
15665 // from focusing the element, so if the anchor gets focused, blur.
15666 // We don't have to worry about focusing the previously focused
15667 // element since clicking on a non-focusable element should focus
15668 // the body anyway.
15669 .delegate( ".ui-tabs-anchor", "focus" + this.eventNamespace, function() {
15670 if ( $( this ).closest( "li" ).is( ".ui-state-disabled" ) ) {
15671 this.blur();
15672 }
15673 });
15674
15675 this.tabs = this.tablist.find( "> li:has(a[href])" )
15676 .addClass( "ui-state-default ui-corner-top" )
15677 .attr({
15678 role: "tab",
15679 tabIndex: -1
15680 });
15681
15682 this.anchors = this.tabs.map(function() {
15683 return $( "a", this )[ 0 ];
15684 })
15685 .addClass( "ui-tabs-anchor" )
15686 .attr({
15687 role: "presentation",
15688 tabIndex: -1
15689 });
15690
15691 this.panels = $();
15692
15693 this.anchors.each(function( i, anchor ) {
15694 var selector, panel, panelId,
15695 anchorId = $( anchor ).uniqueId().attr( "id" ),
15696 tab = $( anchor ).closest( "li" ),
15697 originalAriaControls = tab.attr( "aria-controls" );
15698
15699 // inline tab
15700 if ( that._isLocal( anchor ) ) {
15701 selector = anchor.hash;
15702 panelId = selector.substring( 1 );
15703 panel = that.element.find( that._sanitizeSelector( selector ) );
15704 // remote tab
15705 } else {
15706 // If the tab doesn't already have aria-controls,
15707 // generate an id by using a throw-away element
15708 panelId = tab.attr( "aria-controls" ) || $( {} ).uniqueId()[ 0 ].id;
15709 selector = "#" + panelId;
15710 panel = that.element.find( selector );
15711 if ( !panel.length ) {
15712 panel = that._createPanel( panelId );
15713 panel.insertAfter( that.panels[ i - 1 ] || that.tablist );
15714 }
15715 panel.attr( "aria-live", "polite" );
15716 }
15717
15718 if ( panel.length) {
15719 that.panels = that.panels.add( panel );
15720 }
15721 if ( originalAriaControls ) {
15722 tab.data( "ui-tabs-aria-controls", originalAriaControls );
15723 }
15724 tab.attr({
15725 "aria-controls": panelId,
15726 "aria-labelledby": anchorId
15727 });
15728 panel.attr( "aria-labelledby", anchorId );
15729 });
15730
15731 this.panels
15732 .addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
15733 .attr( "role", "tabpanel" );
15734
15735 // Avoid memory leaks (#10056)
15736 if ( prevTabs ) {
15737 this._off( prevTabs.not( this.tabs ) );
15738 this._off( prevAnchors.not( this.anchors ) );
15739 this._off( prevPanels.not( this.panels ) );
15740 }
15741 },
15742
15743 // allow overriding how to find the list for rare usage scenarios (#7715)
15744 _getList: function() {
15745 return this.tablist || this.element.find( "ol,ul" ).eq( 0 );
15746 },
15747
15748 _createPanel: function( id ) {
15749 return $( "<div>" )
15750 .attr( "id", id )
15751 .addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
15752 .data( "ui-tabs-destroy", true );
15753 },
15754
15755 _setupDisabled: function( disabled ) {
15756 if ( $.isArray( disabled ) ) {
15757 if ( !disabled.length ) {
15758 disabled = false;
15759 } else if ( disabled.length === this.anchors.length ) {
15760 disabled = true;
15761 }
15762 }
15763
15764 // disable tabs
15765 for ( var i = 0, li; ( li = this.tabs[ i ] ); i++ ) {
15766 if ( disabled === true || $.inArray( i, disabled ) !== -1 ) {
15767 $( li )
15768 .addClass( "ui-state-disabled" )
15769 .attr( "aria-disabled", "true" );
15770 } else {
15771 $( li )
15772 .removeClass( "ui-state-disabled" )
15773 .removeAttr( "aria-disabled" );
15774 }
15775 }
15776
15777 this.options.disabled = disabled;
15778 },
15779
15780 _setupEvents: function( event ) {
15781 var events = {};
15782 if ( event ) {
15783 $.each( event.split(" "), function( index, eventName ) {
15784 events[ eventName ] = "_eventHandler";
15785 });
15786 }
15787
15788 this._off( this.anchors.add( this.tabs ).add( this.panels ) );
15789 // Always prevent the default action, even when disabled
15790 this._on( true, this.anchors, {
15791 click: function( event ) {
15792 event.preventDefault();
15793 }
15794 });
15795 this._on( this.anchors, events );
15796 this._on( this.tabs, { keydown: "_tabKeydown" } );
15797 this._on( this.panels, { keydown: "_panelKeydown" } );
15798
15799 this._focusable( this.tabs );
15800 this._hoverable( this.tabs );
15801 },
15802
15803 _setupHeightStyle: function( heightStyle ) {
15804 var maxHeight,
15805 parent = this.element.parent();
15806
15807 if ( heightStyle === "fill" ) {
15808 maxHeight = parent.height();
15809 maxHeight -= this.element.outerHeight() - this.element.height();
15810
15811 this.element.siblings( ":visible" ).each(function() {
15812 var elem = $( this ),
15813 position = elem.css( "position" );
15814
15815 if ( position === "absolute" || position === "fixed" ) {
15816 return;
15817 }
15818 maxHeight -= elem.outerHeight( true );
15819 });
15820
15821 this.element.children().not( this.panels ).each(function() {
15822 maxHeight -= $( this ).outerHeight( true );
15823 });
15824
15825 this.panels.each(function() {
15826 $( this ).height( Math.max( 0, maxHeight -
15827 $( this ).innerHeight() + $( this ).height() ) );
15828 })
15829 .css( "overflow", "auto" );
15830 } else if ( heightStyle === "auto" ) {
15831 maxHeight = 0;
15832 this.panels.each(function() {
15833 maxHeight = Math.max( maxHeight, $( this ).height( "" ).height() );
15834 }).height( maxHeight );
15835 }
15836 },
15837
15838 _eventHandler: function( event ) {
15839 var options = this.options,
15840 active = this.active,
15841 anchor = $( event.currentTarget ),
15842 tab = anchor.closest( "li" ),
15843 clickedIsActive = tab[ 0 ] === active[ 0 ],
15844 collapsing = clickedIsActive && options.collapsible,
15845 toShow = collapsing ? $() : this._getPanelForTab( tab ),
15846 toHide = !active.length ? $() : this._getPanelForTab( active ),
15847 eventData = {
15848 oldTab: active,
15849 oldPanel: toHide,
15850 newTab: collapsing ? $() : tab,
15851 newPanel: toShow
15852 };
15853
15854 event.preventDefault();
15855
15856 if ( tab.hasClass( "ui-state-disabled" ) ||
15857 // tab is already loading
15858 tab.hasClass( "ui-tabs-loading" ) ||
15859 // can't switch durning an animation
15860 this.running ||
15861 // click on active header, but not collapsible
15862 ( clickedIsActive && !options.collapsible ) ||
15863 // allow canceling activation
15864 ( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
15865 return;
15866 }
15867
15868 options.active = collapsing ? false : this.tabs.index( tab );
15869
15870 this.active = clickedIsActive ? $() : tab;
15871 if ( this.xhr ) {
15872 this.xhr.abort();
15873 }
15874
15875 if ( !toHide.length && !toShow.length ) {
15876 $.error( "jQuery UI Tabs: Mismatching fragment identifier." );
15877 }
15878
15879 if ( toShow.length ) {
15880 this.load( this.tabs.index( tab ), event );
15881 }
15882 this._toggle( event, eventData );
15883 },
15884
15885 // handles show/hide for selecting tabs
15886 _toggle: function( event, eventData ) {
15887 var that = this,
15888 toShow = eventData.newPanel,
15889 toHide = eventData.oldPanel;
15890
15891 this.running = true;
15892
15893 function complete() {
15894 that.running = false;
15895 that._trigger( "activate", event, eventData );
15896 }
15897
15898 function show() {
15899 eventData.newTab.closest( "li" ).addClass( "ui-tabs-active ui-state-active" );
15900
15901 if ( toShow.length && that.options.show ) {
15902 that._show( toShow, that.options.show, complete );
15903 } else {
15904 toShow.show();
15905 complete();
15906 }
15907 }
15908
15909 // start out by hiding, then showing, then completing
15910 if ( toHide.length && this.options.hide ) {
15911 this._hide( toHide, this.options.hide, function() {
15912 eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" );
15913 show();
15914 });
15915 } else {
15916 eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" );
15917 toHide.hide();
15918 show();
15919 }
15920
15921 toHide.attr( "aria-hidden", "true" );
15922 eventData.oldTab.attr({
15923 "aria-selected": "false",
15924 "aria-expanded": "false"
15925 });
15926 // If we're switching tabs, remove the old tab from the tab order.
15927 // If we're opening from collapsed state, remove the previous tab from the tab order.
15928 // If we're collapsing, then keep the collapsing tab in the tab order.
15929 if ( toShow.length && toHide.length ) {
15930 eventData.oldTab.attr( "tabIndex", -1 );
15931 } else if ( toShow.length ) {
15932 this.tabs.filter(function() {
15933 return $( this ).attr( "tabIndex" ) === 0;
15934 })
15935 .attr( "tabIndex", -1 );
15936 }
15937
15938 toShow.attr( "aria-hidden", "false" );
15939 eventData.newTab.attr({
15940 "aria-selected": "true",
15941 "aria-expanded": "true",
15942 tabIndex: 0
15943 });
15944 },
15945
15946 _activate: function( index ) {
15947 var anchor,
15948 active = this._findActive( index );
15949
15950 // trying to activate the already active panel
15951 if ( active[ 0 ] === this.active[ 0 ] ) {
15952 return;
15953 }
15954
15955 // trying to collapse, simulate a click on the current active header
15956 if ( !active.length ) {
15957 active = this.active;
15958 }
15959
15960 anchor = active.find( ".ui-tabs-anchor" )[ 0 ];
15961 this._eventHandler({
15962 target: anchor,
15963 currentTarget: anchor,
15964 preventDefault: $.noop
15965 });
15966 },
15967
15968 _findActive: function( index ) {
15969 return index === false ? $() : this.tabs.eq( index );
15970 },
15971
15972 _getIndex: function( index ) {
15973 // meta-function to give users option to provide a href string instead of a numerical index.
15974 if ( typeof index === "string" ) {
15975 index = this.anchors.index( this.anchors.filter( "[href$='" + index + "']" ) );
15976 }
15977
15978 return index;
15979 },
15980
15981 _destroy: function() {
15982 if ( this.xhr ) {
15983 this.xhr.abort();
15984 }
15985
15986 this.element.removeClass( "ui-tabs ui-widget ui-widget-content ui-corner-all ui-tabs-collapsible" );
15987
15988 this.tablist
15989 .removeClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
15990 .removeAttr( "role" );
15991
15992 this.anchors
15993 .removeClass( "ui-tabs-anchor" )
15994 .removeAttr( "role" )
15995 .removeAttr( "tabIndex" )
15996 .removeUniqueId();
15997
15998 this.tablist.unbind( this.eventNamespace );
15999
16000 this.tabs.add( this.panels ).each(function() {
16001 if ( $.data( this, "ui-tabs-destroy" ) ) {
16002 $( this ).remove();
16003 } else {
16004 $( this )
16005 .removeClass( "ui-state-default ui-state-active ui-state-disabled " +
16006 "ui-corner-top ui-corner-bottom ui-widget-content ui-tabs-active ui-tabs-panel" )
16007 .removeAttr( "tabIndex" )
16008 .removeAttr( "aria-live" )
16009 .removeAttr( "aria-busy" )
16010 .removeAttr( "aria-selected" )
16011 .removeAttr( "aria-labelledby" )
16012 .removeAttr( "aria-hidden" )
16013 .removeAttr( "aria-expanded" )
16014 .removeAttr( "role" );
16015 }
16016 });
16017
16018 this.tabs.each(function() {
16019 var li = $( this ),
16020 prev = li.data( "ui-tabs-aria-controls" );
16021 if ( prev ) {
16022 li
16023 .attr( "aria-controls", prev )
16024 .removeData( "ui-tabs-aria-controls" );
16025 } else {
16026 li.removeAttr( "aria-controls" );
16027 }
16028 });
16029
16030 this.panels.show();
16031
16032 if ( this.options.heightStyle !== "content" ) {
16033 this.panels.css( "height", "" );
16034 }
16035 },
16036
16037 enable: function( index ) {
16038 var disabled = this.options.disabled;
16039 if ( disabled === false ) {
16040 return;
16041 }
16042
16043 if ( index === undefined ) {
16044 disabled = false;
16045 } else {
16046 index = this._getIndex( index );
16047 if ( $.isArray( disabled ) ) {
16048 disabled = $.map( disabled, function( num ) {
16049 return num !== index ? num : null;
16050 });
16051 } else {
16052 disabled = $.map( this.tabs, function( li, num ) {
16053 return num !== index ? num : null;
16054 });
16055 }
16056 }
16057 this._setupDisabled( disabled );
16058 },
16059
16060 disable: function( index ) {
16061 var disabled = this.options.disabled;
16062 if ( disabled === true ) {
16063 return;
16064 }
16065
16066 if ( index === undefined ) {
16067 disabled = true;
16068 } else {
16069 index = this._getIndex( index );
16070 if ( $.inArray( index, disabled ) !== -1 ) {
16071 return;
16072 }
16073 if ( $.isArray( disabled ) ) {
16074 disabled = $.merge( [ index ], disabled ).sort();
16075 } else {
16076 disabled = [ index ];
16077 }
16078 }
16079 this._setupDisabled( disabled );
16080 },
16081
16082 load: function( index, event ) {
16083 index = this._getIndex( index );
16084 var that = this,
16085 tab = this.tabs.eq( index ),
16086 anchor = tab.find( ".ui-tabs-anchor" ),
16087 panel = this._getPanelForTab( tab ),
16088 eventData = {
16089 tab: tab,
16090 panel: panel
16091 },
16092 complete = function( jqXHR, status ) {
16093 if ( status === "abort" ) {
16094 that.panels.stop( false, true );
16095 }
16096
16097 tab.removeClass( "ui-tabs-loading" );
16098 panel.removeAttr( "aria-busy" );
16099
16100 if ( jqXHR === that.xhr ) {
16101 delete that.xhr;
16102 }
16103 };
16104
16105 // not remote
16106 if ( this._isLocal( anchor[ 0 ] ) ) {
16107 return;
16108 }
16109
16110 this.xhr = $.ajax( this._ajaxSettings( anchor, event, eventData ) );
16111
16112 // support: jQuery <1.8
16113 // jQuery <1.8 returns false if the request is canceled in beforeSend,
16114 // but as of 1.8, $.ajax() always returns a jqXHR object.
16115 if ( this.xhr && this.xhr.statusText !== "canceled" ) {
16116 tab.addClass( "ui-tabs-loading" );
16117 panel.attr( "aria-busy", "true" );
16118
16119 this.xhr
16120 .done(function( response, status, jqXHR ) {
16121 // support: jQuery <1.8
16122 // http://bugs.jquery.com/ticket/11778
16123 setTimeout(function() {
16124 panel.html( response );
16125 that._trigger( "load", event, eventData );
16126
16127 complete( jqXHR, status );
16128 }, 1 );
16129 })
16130 .fail(function( jqXHR, status ) {
16131 // support: jQuery <1.8
16132 // http://bugs.jquery.com/ticket/11778
16133 setTimeout(function() {
16134 complete( jqXHR, status );
16135 }, 1 );
16136 });
16137 }
16138 },
16139
16140 _ajaxSettings: function( anchor, event, eventData ) {
16141 var that = this;
16142 return {
16143 url: anchor.attr( "href" ),
16144 beforeSend: function( jqXHR, settings ) {
16145 return that._trigger( "beforeLoad", event,
16146 $.extend( { jqXHR: jqXHR, ajaxSettings: settings }, eventData ) );
16147 }
16148 };
16149 },
16150
16151 _getPanelForTab: function( tab ) {
16152 var id = $( tab ).attr( "aria-controls" );
16153 return this.element.find( this._sanitizeSelector( "#" + id ) );
16154 }
16155 });
16156
16157
16158 /*!
16159 * jQuery UI Tooltip 1.11.4
16160 * http://jqueryui.com
16161 *
16162 * Copyright jQuery Foundation and other contributors
16163 * Released under the MIT license.
16164 * http://jquery.org/license
16165 *
16166 * http://api.jqueryui.com/tooltip/
16167 */
16168
16169
16170 var tooltip = $.widget( "ui.tooltip", {
16171 version: "1.11.4",
16172 options: {
16173 content: function() {
16174 // support: IE<9, Opera in jQuery <1.7
16175 // .text() can't accept undefined, so coerce to a string
16176 var title = $( this ).attr( "title" ) || "";
16177 // Escape title, since we're going from an attribute to raw HTML
16178 return $( "<a>" ).text( title ).html();
16179 },
16180 hide: true,
16181 // Disabled elements have inconsistent behavior across browsers (#8661)
16182 items: "[title]:not([disabled])",
16183 position: {
16184 my: "left top+15",
16185 at: "left bottom",
16186 collision: "flipfit flip"
16187 },
16188 show: true,
16189 tooltipClass: null,
16190 track: false,
16191
16192 // callbacks
16193 close: null,
16194 open: null
16195 },
16196
16197 _addDescribedBy: function( elem, id ) {
16198 var describedby = (elem.attr( "aria-describedby" ) || "").split( /\s+/ );
16199 describedby.push( id );
16200 elem
16201 .data( "ui-tooltip-id", id )
16202 .attr( "aria-describedby", $.trim( describedby.join( " " ) ) );
16203 },
16204
16205 _removeDescribedBy: function( elem ) {
16206 var id = elem.data( "ui-tooltip-id" ),
16207 describedby = (elem.attr( "aria-describedby" ) || "").split( /\s+/ ),
16208 index = $.inArray( id, describedby );
16209
16210 if ( index !== -1 ) {
16211 describedby.splice( index, 1 );
16212 }
16213
16214 elem.removeData( "ui-tooltip-id" );
16215 describedby = $.trim( describedby.join( " " ) );
16216 if ( describedby ) {
16217 elem.attr( "aria-describedby", describedby );
16218 } else {
16219 elem.removeAttr( "aria-describedby" );
16220 }
16221 },
16222
16223 _create: function() {
16224 this._on({
16225 mouseover: "open",
16226 focusin: "open"
16227 });
16228
16229 // IDs of generated tooltips, needed for destroy
16230 this.tooltips = {};
16231
16232 // IDs of parent tooltips where we removed the title attribute
16233 this.parents = {};
16234
16235 if ( this.options.disabled ) {
16236 this._disable();
16237 }
16238
16239 // Append the aria-live region so tooltips announce correctly
16240 this.liveRegion = $( "<div>" )
16241 .attr({
16242 role: "log",
16243 "aria-live": "assertive",
16244 "aria-relevant": "additions"
16245 })
16246 .addClass( "ui-helper-hidden-accessible" )
16247 .appendTo( this.document[ 0 ].body );
16248 },
16249
16250 _setOption: function( key, value ) {
16251 var that = this;
16252
16253 if ( key === "disabled" ) {
16254 this[ value ? "_disable" : "_enable" ]();
16255 this.options[ key ] = value;
16256 // disable element style changes
16257 return;
16258 }
16259
16260 this._super( key, value );
16261
16262 if ( key === "content" ) {
16263 $.each( this.tooltips, function( id, tooltipData ) {
16264 that._updateContent( tooltipData.element );
16265 });
16266 }
16267 },
16268
16269 _disable: function() {
16270 var that = this;
16271
16272 // close open tooltips
16273 $.each( this.tooltips, function( id, tooltipData ) {
16274 var event = $.Event( "blur" );
16275 event.target = event.currentTarget = tooltipData.element[ 0 ];
16276 that.close( event, true );
16277 });
16278
16279 // remove title attributes to prevent native tooltips
16280 this.element.find( this.options.items ).addBack().each(function() {
16281 var element = $( this );
16282 if ( element.is( "[title]" ) ) {
16283 element
16284 .data( "ui-tooltip-title", element.attr( "title" ) )
16285 .removeAttr( "title" );
16286 }
16287 });
16288 },
16289
16290 _enable: function() {
16291 // restore title attributes
16292 this.element.find( this.options.items ).addBack().each(function() {
16293 var element = $( this );
16294 if ( element.data( "ui-tooltip-title" ) ) {
16295 element.attr( "title", element.data( "ui-tooltip-title" ) );
16296 }
16297 });
16298 },
16299
16300 open: function( event ) {
16301 var that = this,
16302 target = $( event ? event.target : this.element )
16303 // we need closest here due to mouseover bubbling,
16304 // but always pointing at the same event target
16305 .closest( this.options.items );
16306
16307 // No element to show a tooltip for or the tooltip is already open
16308 if ( !target.length || target.data( "ui-tooltip-id" ) ) {
16309 return;
16310 }
16311
16312 if ( target.attr( "title" ) ) {
16313 target.data( "ui-tooltip-title", target.attr( "title" ) );
16314 }
16315
16316 target.data( "ui-tooltip-open", true );
16317
16318 // kill parent tooltips, custom or native, for hover
16319 if ( event && event.type === "mouseover" ) {
16320 target.parents().each(function() {
16321 var parent = $( this ),
16322 blurEvent;
16323 if ( parent.data( "ui-tooltip-open" ) ) {
16324 blurEvent = $.Event( "blur" );
16325 blurEvent.target = blurEvent.currentTarget = this;
16326 that.close( blurEvent, true );
16327 }
16328 if ( parent.attr( "title" ) ) {
16329 parent.uniqueId();
16330 that.parents[ this.id ] = {
16331 element: this,
16332 title: parent.attr( "title" )
16333 };
16334 parent.attr( "title", "" );
16335 }
16336 });
16337 }
16338
16339 this._registerCloseHandlers( event, target );
16340 this._updateContent( target, event );
16341 },
16342
16343 _updateContent: function( target, event ) {
16344 var content,
16345 contentOption = this.options.content,
16346 that = this,
16347 eventType = event ? event.type : null;
16348
16349 if ( typeof contentOption === "string" ) {
16350 return this._open( event, target, contentOption );
16351 }
16352
16353 content = contentOption.call( target[0], function( response ) {
16354
16355 // IE may instantly serve a cached response for ajax requests
16356 // delay this call to _open so the other call to _open runs first
16357 that._delay(function() {
16358
16359 // Ignore async response if tooltip was closed already
16360 if ( !target.data( "ui-tooltip-open" ) ) {
16361 return;
16362 }
16363
16364 // jQuery creates a special event for focusin when it doesn't
16365 // exist natively. To improve performance, the native event
16366 // object is reused and the type is changed. Therefore, we can't
16367 // rely on the type being correct after the event finished
16368 // bubbling, so we set it back to the previous value. (#8740)
16369 if ( event ) {
16370 event.type = eventType;
16371 }
16372 this._open( event, target, response );
16373 });
16374 });
16375 if ( content ) {
16376 this._open( event, target, content );
16377 }
16378 },
16379
16380 _open: function( event, target, content ) {
16381 var tooltipData, tooltip, delayedShow, a11yContent,
16382 positionOption = $.extend( {}, this.options.position );
16383
16384 if ( !content ) {
16385 return;
16386 }
16387
16388 // Content can be updated multiple times. If the tooltip already
16389 // exists, then just update the content and bail.
16390 tooltipData = this._find( target );
16391 if ( tooltipData ) {
16392 tooltipData.tooltip.find( ".ui-tooltip-content" ).html( content );
16393 return;
16394 }
16395
16396 // if we have a title, clear it to prevent the native tooltip
16397 // we have to check first to avoid defining a title if none exists
16398 // (we don't want to cause an element to start matching [title])
16399 //
16400 // We use removeAttr only for key events, to allow IE to export the correct
16401 // accessible attributes. For mouse events, set to empty string to avoid
16402 // native tooltip showing up (happens only when removing inside mouseover).
16403 if ( target.is( "[title]" ) ) {
16404 if ( event && event.type === "mouseover" ) {
16405 target.attr( "title", "" );
16406 } else {
16407 target.removeAttr( "title" );
16408 }
16409 }
16410
16411 tooltipData = this._tooltip( target );
16412 tooltip = tooltipData.tooltip;
16413 this._addDescribedBy( target, tooltip.attr( "id" ) );
16414 tooltip.find( ".ui-tooltip-content" ).html( content );
16415
16416 // Support: Voiceover on OS X, JAWS on IE <= 9
16417 // JAWS announces deletions even when aria-relevant="additions"
16418 // Voiceover will sometimes re-read the entire log region's contents from the beginning
16419 this.liveRegion.children().hide();
16420 if ( content.clone ) {
16421 a11yContent = content.clone();
16422 a11yContent.removeAttr( "id" ).find( "[id]" ).removeAttr( "id" );
16423 } else {
16424 a11yContent = content;
16425 }
16426 $( "<div>" ).html( a11yContent ).appendTo( this.liveRegion );
16427
16428 function position( event ) {
16429 positionOption.of = event;
16430 if ( tooltip.is( ":hidden" ) ) {
16431 return;
16432 }
16433 tooltip.position( positionOption );
16434 }
16435 if ( this.options.track && event && /^mouse/.test( event.type ) ) {
16436 this._on( this.document, {
16437 mousemove: position
16438 });
16439 // trigger once to override element-relative positioning
16440 position( event );
16441 } else {
16442 tooltip.position( $.extend({
16443 of: target
16444 }, this.options.position ) );
16445 }
16446
16447 tooltip.hide();
16448
16449 this._show( tooltip, this.options.show );
16450 // Handle tracking tooltips that are shown with a delay (#8644). As soon
16451 // as the tooltip is visible, position the tooltip using the most recent
16452 // event.
16453 if ( this.options.show && this.options.show.delay ) {
16454 delayedShow = this.delayedShow = setInterval(function() {
16455 if ( tooltip.is( ":visible" ) ) {
16456 position( positionOption.of );
16457 clearInterval( delayedShow );
16458 }
16459 }, $.fx.interval );
16460 }
16461
16462 this._trigger( "open", event, { tooltip: tooltip } );
16463 },
16464
16465 _registerCloseHandlers: function( event, target ) {
16466 var events = {
16467 keyup: function( event ) {
16468 if ( event.keyCode === $.ui.keyCode.ESCAPE ) {
16469 var fakeEvent = $.Event(event);
16470 fakeEvent.currentTarget = target[0];
16471 this.close( fakeEvent, true );
16472 }
16473 }
16474 };
16475
16476 // Only bind remove handler for delegated targets. Non-delegated
16477 // tooltips will handle this in destroy.
16478 if ( target[ 0 ] !== this.element[ 0 ] ) {
16479 events.remove = function() {
16480 this._removeTooltip( this._find( target ).tooltip );
16481 };
16482 }
16483
16484 if ( !event || event.type === "mouseover" ) {
16485 events.mouseleave = "close";
16486 }
16487 if ( !event || event.type === "focusin" ) {
16488 events.focusout = "close";
16489 }
16490 this._on( true, target, events );
16491 },
16492
16493 close: function( event ) {
16494 var tooltip,
16495 that = this,
16496 target = $( event ? event.currentTarget : this.element ),
16497 tooltipData = this._find( target );
16498
16499 // The tooltip may already be closed
16500 if ( !tooltipData ) {
16501
16502 // We set ui-tooltip-open immediately upon open (in open()), but only set the
16503 // additional data once there's actually content to show (in _open()). So even if the
16504 // tooltip doesn't have full data, we always remove ui-tooltip-open in case we're in
16505 // the period between open() and _open().
16506 target.removeData( "ui-tooltip-open" );
16507 return;
16508 }
16509
16510 tooltip = tooltipData.tooltip;
16511
16512 // disabling closes the tooltip, so we need to track when we're closing
16513 // to avoid an infinite loop in case the tooltip becomes disabled on close
16514 if ( tooltipData.closing ) {
16515 return;
16516 }
16517
16518 // Clear the interval for delayed tracking tooltips
16519 clearInterval( this.delayedShow );
16520
16521 // only set title if we had one before (see comment in _open())
16522 // If the title attribute has changed since open(), don't restore
16523 if ( target.data( "ui-tooltip-title" ) && !target.attr( "title" ) ) {
16524 target.attr( "title", target.data( "ui-tooltip-title" ) );
16525 }
16526
16527 this._removeDescribedBy( target );
16528
16529 tooltipData.hiding = true;
16530 tooltip.stop( true );
16531 this._hide( tooltip, this.options.hide, function() {
16532 that._removeTooltip( $( this ) );
16533 });
16534
16535 target.removeData( "ui-tooltip-open" );
16536 this._off( target, "mouseleave focusout keyup" );
16537
16538 // Remove 'remove' binding only on delegated targets
16539 if ( target[ 0 ] !== this.element[ 0 ] ) {
16540 this._off( target, "remove" );
16541 }
16542 this._off( this.document, "mousemove" );
16543
16544 if ( event && event.type === "mouseleave" ) {
16545 $.each( this.parents, function( id, parent ) {
16546 $( parent.element ).attr( "title", parent.title );
16547 delete that.parents[ id ];
16548 });
16549 }
16550
16551 tooltipData.closing = true;
16552 this._trigger( "close", event, { tooltip: tooltip } );
16553 if ( !tooltipData.hiding ) {
16554 tooltipData.closing = false;
16555 }
16556 },
16557
16558 _tooltip: function( element ) {
16559 var tooltip = $( "<div>" )
16560 .attr( "role", "tooltip" )
16561 .addClass( "ui-tooltip ui-widget ui-corner-all ui-widget-content " +
16562 ( this.options.tooltipClass || "" ) ),
16563 id = tooltip.uniqueId().attr( "id" );
16564
16565 $( "<div>" )
16566 .addClass( "ui-tooltip-content" )
16567 .appendTo( tooltip );
16568
16569 tooltip.appendTo( this.document[0].body );
16570
16571 return this.tooltips[ id ] = {
16572 element: element,
16573 tooltip: tooltip
16574 };
16575 },
16576
16577 _find: function( target ) {
16578 var id = target.data( "ui-tooltip-id" );
16579 return id ? this.tooltips[ id ] : null;
16580 },
16581
16582 _removeTooltip: function( tooltip ) {
16583 tooltip.remove();
16584 delete this.tooltips[ tooltip.attr( "id" ) ];
16585 },
16586
16587 _destroy: function() {
16588 var that = this;
16589
16590 // close open tooltips
16591 $.each( this.tooltips, function( id, tooltipData ) {
16592 // Delegate to close method to handle common cleanup
16593 var event = $.Event( "blur" ),
16594 element = tooltipData.element;
16595 event.target = event.currentTarget = element[ 0 ];
16596 that.close( event, true );
16597
16598 // Remove immediately; destroying an open tooltip doesn't use the
16599 // hide animation
16600 $( "#" + id ).remove();
16601
16602 // Restore the title
16603 if ( element.data( "ui-tooltip-title" ) ) {
16604 // If the title attribute has changed since open(), don't restore
16605 if ( !element.attr( "title" ) ) {
16606 element.attr( "title", element.data( "ui-tooltip-title" ) );
16607 }
16608 element.removeData( "ui-tooltip-title" );
16609 }
16610 });
16611 this.liveRegion.remove();
16612 }
16613 });
16614
16615
16616
16617 }));
2 * http://jqueryui.com
3 * Includes: core.js, widget.js, mouse.js, position.js, accordion.js, autocomplete.js, button.js, datepicker.js, dialog.js, draggable.js, droppable.js, effect.js, effect-blind.js, effect-bounce.js, effect-clip.js, effect-drop.js, effect-explode.js, effect-fade.js, effect-fold.js, effect-highlight.js, effect-puff.js, effect-pulsate.js, effect-scale.js, effect-shake.js, effect-size.js, effect-slide.js, effect-transfer.js, menu.js, progressbar.js, resizable.js, selectable.js, selectmenu.js, slider.js, sortable.js, spinner.js, tabs.js, tooltip.js
4 * Copyright 2015 jQuery Foundation and other contributors; Licensed MIT */
5
6 (function( factory ) {
7 if ( typeof define === "function" && define.amd ) {
8
9 // AMD. Register as an anonymous module.
10 define([ "jquery" ], factory );
11 } else {
12
13 // Browser globals
14 factory( jQuery );
15 }
16 }(function( $ ) {
17 /*!
18 * jQuery UI Core 1.11.4
19 * http://jqueryui.com
20 *
21 * Copyright jQuery Foundation and other contributors
22 * Released under the MIT license.
23 * http://jquery.org/license
24 *
25 * http://api.jqueryui.com/category/ui-core/
26 */
27
28
29 // $.ui might exist from components with no dependencies, e.g., $.ui.position
30 $.ui = $.ui || {};
31
32 $.extend( $.ui, {
33 version: "1.11.4",
34
35 keyCode: {
36 BACKSPACE: 8,
37 COMMA: 188,
38 DELETE: 46,
39 DOWN: 40,
40 END: 35,
41 ENTER: 13,
42 ESCAPE: 27,
43 HOME: 36,
44 LEFT: 37,
45 PAGE_DOWN: 34,
46 PAGE_UP: 33,
47 PERIOD: 190,
48 RIGHT: 39,
49 SPACE: 32,
50 TAB: 9,
51 UP: 38
52 }
53 });
54
55 // plugins
56 $.fn.extend({
57 scrollParent: function( includeHidden ) {
58 var position = this.css( "position" ),
59 excludeStaticParent = position === "absolute",
60 overflowRegex = includeHidden ? /(auto|scroll|hidden)/ : /(auto|scroll)/,
61 scrollParent = this.parents().filter( function() {
62 var parent = $( this );
63 if ( excludeStaticParent && parent.css( "position" ) === "static" ) {
64 return false;
65 }
66 return overflowRegex.test( parent.css( "overflow" ) + parent.css( "overflow-y" ) + parent.css( "overflow-x" ) );
67 }).eq( 0 );
68
69 return position === "fixed" || !scrollParent.length ? $( this[ 0 ].ownerDocument || document ) : scrollParent;
70 },
71
72 uniqueId: (function() {
73 var uuid = 0;
74
75 return function() {
76 return this.each(function() {
77 if ( !this.id ) {
78 this.id = "ui-id-" + ( ++uuid );
79 }
80 });
81 };
82 })(),
83
84 removeUniqueId: function() {
85 return this.each(function() {
86 if ( /^ui-id-\d+$/.test( this.id ) ) {
87 $( this ).removeAttr( "id" );
88 }
89 });
90 }
91 });
92
93 // selectors
94 function focusable( element, isTabIndexNotNaN ) {
95 var map, mapName, img,
96 nodeName = element.nodeName.toLowerCase();
97 if ( "area" === nodeName ) {
98 map = element.parentNode;
99 mapName = map.name;
100 if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
101 return false;
102 }
103 img = $( "img[usemap='#" + mapName + "']" )[ 0 ];
104 return !!img && visible( img );
105 }
106 return ( /^(input|select|textarea|button|object)$/.test( nodeName ) ?
107 !element.disabled :
108 "a" === nodeName ?
109 element.href || isTabIndexNotNaN :
110 isTabIndexNotNaN) &&
111 // the element and all of its ancestors must be visible
112 visible( element );
113 }
114
115 function visible( element ) {
116 return $.expr.filters.visible( element ) &&
117 !$( element ).parents().addBack().filter(function() {
118 return $.css( this, "visibility" ) === "hidden";
119 }).length;
120 }
121
122 $.extend( $.expr[ ":" ], {
123 data: $.expr.createPseudo ?
124 $.expr.createPseudo(function( dataName ) {
125 return function( elem ) {
126 return !!$.data( elem, dataName );
127 };
128 }) :
129 // support: jQuery <1.8
130 function( elem, i, match ) {
131 return !!$.data( elem, match[ 3 ] );
132 },
133
134 focusable: function( element ) {
135 return focusable( element, !isNaN( $.attr( element, "tabindex" ) ) );
136 },
137
138 tabbable: function( element ) {
139 var tabIndex = $.attr( element, "tabindex" ),
140 isTabIndexNaN = isNaN( tabIndex );
141 return ( isTabIndexNaN || tabIndex >= 0 ) && focusable( element, !isTabIndexNaN );
142 }
143 });
144
145 // support: jQuery <1.8
146 if ( !$( "<a>" ).outerWidth( 1 ).jquery ) {
147 $.each( [ "Width", "Height" ], function( i, name ) {
148 var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
149 type = name.toLowerCase(),
150 orig = {
151 innerWidth: $.fn.innerWidth,
152 innerHeight: $.fn.innerHeight,
153 outerWidth: $.fn.outerWidth,
154 outerHeight: $.fn.outerHeight
155 };
156
157 function reduce( elem, size, border, margin ) {
158 $.each( side, function() {
159 size -= parseFloat( $.css( elem, "padding" + this ) ) || 0;
160 if ( border ) {
161 size -= parseFloat( $.css( elem, "border" + this + "Width" ) ) || 0;
162 }
163 if ( margin ) {
164 size -= parseFloat( $.css( elem, "margin" + this ) ) || 0;
165 }
166 });
167 return size;
168 }
169
170 $.fn[ "inner" + name ] = function( size ) {
171 if ( size === undefined ) {
172 return orig[ "inner" + name ].call( this );
173 }
174
175 return this.each(function() {
176 $( this ).css( type, reduce( this, size ) + "px" );
177 });
178 };
179
180 $.fn[ "outer" + name] = function( size, margin ) {
181 if ( typeof size !== "number" ) {
182 return orig[ "outer" + name ].call( this, size );
183 }
184
185 return this.each(function() {
186 $( this).css( type, reduce( this, size, true, margin ) + "px" );
187 });
188 };
189 });
190 }
191
192 // support: jQuery <1.8
193 if ( !$.fn.addBack ) {
194 $.fn.addBack = function( selector ) {
195 return this.add( selector == null ?
196 this.prevObject : this.prevObject.filter( selector )
197 );
198 };
199 }
200
201 // support: jQuery 1.6.1, 1.6.2 (http://bugs.jquery.com/ticket/9413)
202 if ( $( "<a>" ).data( "a-b", "a" ).removeData( "a-b" ).data( "a-b" ) ) {
203 $.fn.removeData = (function( removeData ) {
204 return function( key ) {
205 if ( arguments.length ) {
206 return removeData.call( this, $.camelCase( key ) );
207 } else {
208 return removeData.call( this );
209 }
210 };
211 })( $.fn.removeData );
212 }
213
214 // deprecated
215 $.ui.ie = !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() );
216
217 $.fn.extend({
218 focus: (function( orig ) {
219 return function( delay, fn ) {
220 return typeof delay === "number" ?
221 this.each(function() {
222 var elem = this;
223 setTimeout(function() {
224 $( elem ).focus();
225 if ( fn ) {
226 fn.call( elem );
227 }
228 }, delay );
229 }) :
230 orig.apply( this, arguments );
231 };
232 })( $.fn.focus ),
233
234 disableSelection: (function() {
235 var eventType = "onselectstart" in document.createElement( "div" ) ?
236 "selectstart" :
237 "mousedown";
238
239 return function() {
240 return this.bind( eventType + ".ui-disableSelection", function( event ) {
241 event.preventDefault();
242 });
243 };
244 })(),
245
246 enableSelection: function() {
247 return this.unbind( ".ui-disableSelection" );
248 },
249
250 zIndex: function( zIndex ) {
251 if ( zIndex !== undefined ) {
252 return this.css( "zIndex", zIndex );
253 }
254
255 if ( this.length ) {
256 var elem = $( this[ 0 ] ), position, value;
257 while ( elem.length && elem[ 0 ] !== document ) {
258 // Ignore z-index if position is set to a value where z-index is ignored by the browser
259 // This makes behavior of this function consistent across browsers
260 // WebKit always returns auto if the element is positioned
261 position = elem.css( "position" );
262 if ( position === "absolute" || position === "relative" || position === "fixed" ) {
263 // IE returns 0 when zIndex is not specified
264 // other browsers return a string
265 // we ignore the case of nested elements with an explicit value of 0
266 // <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
267 value = parseInt( elem.css( "zIndex" ), 10 );
268 if ( !isNaN( value ) && value !== 0 ) {
269 return value;
270 }
271 }
272 elem = elem.parent();
273 }
274 }
275
276 return 0;
277 }
278 });
279
280 // $.ui.plugin is deprecated. Use $.widget() extensions instead.
281 $.ui.plugin = {
282 add: function( module, option, set ) {
283 var i,
284 proto = $.ui[ module ].prototype;
285 for ( i in set ) {
286 proto.plugins[ i ] = proto.plugins[ i ] || [];
287 proto.plugins[ i ].push( [ option, set[ i ] ] );
288 }
289 },
290 call: function( instance, name, args, allowDisconnected ) {
291 var i,
292 set = instance.plugins[ name ];
293
294 if ( !set ) {
295 return;
296 }
297
298 if ( !allowDisconnected && ( !instance.element[ 0 ].parentNode || instance.element[ 0 ].parentNode.nodeType === 11 ) ) {
299 return;
300 }
301
302 for ( i = 0; i < set.length; i++ ) {
303 if ( instance.options[ set[ i ][ 0 ] ] ) {
304 set[ i ][ 1 ].apply( instance.element, args );
305 }
306 }
307 }
308 };
309
310
311 /*!
312 * jQuery UI Widget 1.11.4
313 * http://jqueryui.com
314 *
315 * Copyright jQuery Foundation and other contributors
316 * Released under the MIT license.
317 * http://jquery.org/license
318 *
319 * http://api.jqueryui.com/jQuery.widget/
320 */
321
322
323 var widget_uuid = 0,
324 widget_slice = Array.prototype.slice;
325
326 $.cleanData = (function( orig ) {
327 return function( elems ) {
328 var events, elem, i;
329 for ( i = 0; (elem = elems[i]) != null; i++ ) {
330 try {
331
332 // Only trigger remove when necessary to save time
333 events = $._data( elem, "events" );
334 if ( events && events.remove ) {
335 $( elem ).triggerHandler( "remove" );
336 }
337
338 // http://bugs.jquery.com/ticket/8235
339 } catch ( e ) {}
340 }
341 orig( elems );
342 };
343 })( $.cleanData );
344
345 $.widget = function( name, base, prototype ) {
346 var fullName, existingConstructor, constructor, basePrototype,
347 // proxiedPrototype allows the provided prototype to remain unmodified
348 // so that it can be used as a mixin for multiple widgets (#8876)
349 proxiedPrototype = {},
350 namespace = name.split( "." )[ 0 ];
351
352 name = name.split( "." )[ 1 ];
353 fullName = namespace + "-" + name;
354
355 if ( !prototype ) {
356 prototype = base;
357 base = $.Widget;
358 }
359
360 // create selector for plugin
361 $.expr[ ":" ][ fullName.toLowerCase() ] = function( elem ) {
362 return !!$.data( elem, fullName );
363 };
364
365 $[ namespace ] = $[ namespace ] || {};
366 existingConstructor = $[ namespace ][ name ];
367 constructor = $[ namespace ][ name ] = function( options, element ) {
368 // allow instantiation without "new" keyword
369 if ( !this._createWidget ) {
370 return new constructor( options, element );
371 }
372
373 // allow instantiation without initializing for simple inheritance
374 // must use "new" keyword (the code above always passes args)
375 if ( arguments.length ) {
376 this._createWidget( options, element );
377 }
378 };
379 // extend with the existing constructor to carry over any static properties
380 $.extend( constructor, existingConstructor, {
381 version: prototype.version,
382 // copy the object used to create the prototype in case we need to
383 // redefine the widget later
384 _proto: $.extend( {}, prototype ),
385 // track widgets that inherit from this widget in case this widget is
386 // redefined after a widget inherits from it
387 _childConstructors: []
388 });
389
390 basePrototype = new base();
391 // we need to make the options hash a property directly on the new instance
392 // otherwise we'll modify the options hash on the prototype that we're
393 // inheriting from
394 basePrototype.options = $.widget.extend( {}, basePrototype.options );
395 $.each( prototype, function( prop, value ) {
396 if ( !$.isFunction( value ) ) {
397 proxiedPrototype[ prop ] = value;
398 return;
399 }
400 proxiedPrototype[ prop ] = (function() {
401 var _super = function() {
402 return base.prototype[ prop ].apply( this, arguments );
403 },
404 _superApply = function( args ) {
405 return base.prototype[ prop ].apply( this, args );
406 };
407 return function() {
408 var __super = this._super,
409 __superApply = this._superApply,
410 returnValue;
411
412 this._super = _super;
413 this._superApply = _superApply;
414
415 returnValue = value.apply( this, arguments );
416
417 this._super = __super;
418 this._superApply = __superApply;
419
420 return returnValue;
421 };
422 })();
423 });
424 constructor.prototype = $.widget.extend( basePrototype, {
425 // TODO: remove support for widgetEventPrefix
426 // always use the name + a colon as the prefix, e.g., draggable:start
427 // don't prefix for widgets that aren't DOM-based
428 widgetEventPrefix: existingConstructor ? (basePrototype.widgetEventPrefix || name) : name
429 }, proxiedPrototype, {
430 constructor: constructor,
431 namespace: namespace,
432 widgetName: name,
433 widgetFullName: fullName
434 });
435
436 // If this widget is being redefined then we need to find all widgets that
437 // are inheriting from it and redefine all of them so that they inherit from
438 // the new version of this widget. We're essentially trying to replace one
439 // level in the prototype chain.
440 if ( existingConstructor ) {
441 $.each( existingConstructor._childConstructors, function( i, child ) {
442 var childPrototype = child.prototype;
443
444 // redefine the child widget using the same prototype that was
445 // originally used, but inherit from the new version of the base
446 $.widget( childPrototype.namespace + "." + childPrototype.widgetName, constructor, child._proto );
447 });
448 // remove the list of existing child constructors from the old constructor
449 // so the old child constructors can be garbage collected
450 delete existingConstructor._childConstructors;
451 } else {
452 base._childConstructors.push( constructor );
453 }
454
455 $.widget.bridge( name, constructor );
456
457 return constructor;
458 };
459
460 $.widget.extend = function( target ) {
461 var input = widget_slice.call( arguments, 1 ),
462 inputIndex = 0,
463 inputLength = input.length,
464 key,
465 value;
466 for ( ; inputIndex < inputLength; inputIndex++ ) {
467 for ( key in input[ inputIndex ] ) {
468 value = input[ inputIndex ][ key ];
469 if ( input[ inputIndex ].hasOwnProperty( key ) && value !== undefined ) {
470 // Clone objects
471 if ( $.isPlainObject( value ) ) {
472 target[ key ] = $.isPlainObject( target[ key ] ) ?
473 $.widget.extend( {}, target[ key ], value ) :
474 // Don't extend strings, arrays, etc. with objects
475 $.widget.extend( {}, value );
476 // Copy everything else by reference
477 } else {
478 target[ key ] = value;
479 }
480 }
481 }
482 }
483 return target;
484 };
485
486 $.widget.bridge = function( name, object ) {
487 var fullName = object.prototype.widgetFullName || name;
488 $.fn[ name ] = function( options ) {
489 var isMethodCall = typeof options === "string",
490 args = widget_slice.call( arguments, 1 ),
491 returnValue = this;
492
493 if ( isMethodCall ) {
494 this.each(function() {
495 var methodValue,
496 instance = $.data( this, fullName );
497 if ( options === "instance" ) {
498 returnValue = instance;
499 return false;
500 }
501 if ( !instance ) {
502 return $.error( "cannot call methods on " + name + " prior to initialization; " +
503 "attempted to call method '" + options + "'" );
504 }
505 if ( !$.isFunction( instance[options] ) || options.charAt( 0 ) === "_" ) {
506 return $.error( "no such method '" + options + "' for " + name + " widget instance" );
507 }
508 methodValue = instance[ options ].apply( instance, args );
509 if ( methodValue !== instance && methodValue !== undefined ) {
510 returnValue = methodValue && methodValue.jquery ?
511 returnValue.pushStack( methodValue.get() ) :
512 methodValue;
513 return false;
514 }
515 });
516 } else {
517
518 // Allow multiple hashes to be passed on init
519 if ( args.length ) {
520 options = $.widget.extend.apply( null, [ options ].concat(args) );
521 }
522
523 this.each(function() {
524 var instance = $.data( this, fullName );
525 if ( instance ) {
526 instance.option( options || {} );
527 if ( instance._init ) {
528 instance._init();
529 }
530 } else {
531 $.data( this, fullName, new object( options, this ) );
532 }
533 });
534 }
535
536 return returnValue;
537 };
538 };
539
540 $.Widget = function( /* options, element */ ) {};
541 $.Widget._childConstructors = [];
542
543 $.Widget.prototype = {
544 widgetName: "widget",
545 widgetEventPrefix: "",
546 defaultElement: "<div>",
547 options: {
548 disabled: false,
549
550 // callbacks
551 create: null
552 },
553 _createWidget: function( options, element ) {
554 element = $( element || this.defaultElement || this )[ 0 ];
555 this.element = $( element );
556 this.uuid = widget_uuid++;
557 this.eventNamespace = "." + this.widgetName + this.uuid;
558
559 this.bindings = $();
560 this.hoverable = $();
561 this.focusable = $();
562
563 if ( element !== this ) {
564 $.data( element, this.widgetFullName, this );
565 this._on( true, this.element, {
566 remove: function( event ) {
567 if ( event.target === element ) {
568 this.destroy();
569 }
570 }
571 });
572 this.document = $( element.style ?
573 // element within the document
574 element.ownerDocument :
575 // element is window or document
576 element.document || element );
577 this.window = $( this.document[0].defaultView || this.document[0].parentWindow );
578 }
579
580 this.options = $.widget.extend( {},
581 this.options,
582 this._getCreateOptions(),
583 options );
584
585 this._create();
586 this._trigger( "create", null, this._getCreateEventData() );
587 this._init();
588 },
589 _getCreateOptions: $.noop,
590 _getCreateEventData: $.noop,
591 _create: $.noop,
592 _init: $.noop,
593
594 destroy: function() {
595 this._destroy();
596 // we can probably remove the unbind calls in 2.0
597 // all event bindings should go through this._on()
598 this.element
599 .unbind( this.eventNamespace )
600 .removeData( this.widgetFullName )
601 // support: jquery <1.6.3
602 // http://bugs.jquery.com/ticket/9413
603 .removeData( $.camelCase( this.widgetFullName ) );
604 this.widget()
605 .unbind( this.eventNamespace )
606 .removeAttr( "aria-disabled" )
607 .removeClass(
608 this.widgetFullName + "-disabled " +
609 "ui-state-disabled" );
610
611 // clean up events and states
612 this.bindings.unbind( this.eventNamespace );
613 this.hoverable.removeClass( "ui-state-hover" );
614 this.focusable.removeClass( "ui-state-focus" );
615 },
616 _destroy: $.noop,
617
618 widget: function() {
619 return this.element;
620 },
621
622 option: function( key, value ) {
623 var options = key,
624 parts,
625 curOption,
626 i;
627
628 if ( arguments.length === 0 ) {
629 // don't return a reference to the internal hash
630 return $.widget.extend( {}, this.options );
631 }
632
633 if ( typeof key === "string" ) {
634 // handle nested keys, e.g., "foo.bar" => { foo: { bar: ___ } }
635 options = {};
636 parts = key.split( "." );
637 key = parts.shift();
638 if ( parts.length ) {
639 curOption = options[ key ] = $.widget.extend( {}, this.options[ key ] );
640 for ( i = 0; i < parts.length - 1; i++ ) {
641 curOption[ parts[ i ] ] = curOption[ parts[ i ] ] || {};
642 curOption = curOption[ parts[ i ] ];
643 }
644 key = parts.pop();
645 if ( arguments.length === 1 ) {
646 return curOption[ key ] === undefined ? null : curOption[ key ];
647 }
648 curOption[ key ] = value;
649 } else {
650 if ( arguments.length === 1 ) {
651 return this.options[ key ] === undefined ? null : this.options[ key ];
652 }
653 options[ key ] = value;
654 }
655 }
656
657 this._setOptions( options );
658
659 return this;
660 },
661 _setOptions: function( options ) {
662 var key;
663
664 for ( key in options ) {
665 this._setOption( key, options[ key ] );
666 }
667
668 return this;
669 },
670 _setOption: function( key, value ) {
671 this.options[ key ] = value;
672
673 if ( key === "disabled" ) {
674 this.widget()
675 .toggleClass( this.widgetFullName + "-disabled", !!value );
676
677 // If the widget is becoming disabled, then nothing is interactive
678 if ( value ) {
679 this.hoverable.removeClass( "ui-state-hover" );
680 this.focusable.removeClass( "ui-state-focus" );
681 }
682 }
683
684 return this;
685 },
686
687 enable: function() {
688 return this._setOptions({ disabled: false });
689 },
690 disable: function() {
691 return this._setOptions({ disabled: true });
692 },
693
694 _on: function( suppressDisabledCheck, element, handlers ) {
695 var delegateElement,
696 instance = this;
697
698 // no suppressDisabledCheck flag, shuffle arguments
699 if ( typeof suppressDisabledCheck !== "boolean" ) {
700 handlers = element;
701 element = suppressDisabledCheck;
702 suppressDisabledCheck = false;
703 }
704
705 // no element argument, shuffle and use this.element
706 if ( !handlers ) {
707 handlers = element;
708 element = this.element;
709 delegateElement = this.widget();
710 } else {
711 element = delegateElement = $( element );
712 this.bindings = this.bindings.add( element );
713 }
714
715 $.each( handlers, function( event, handler ) {
716 function handlerProxy() {
717 // allow widgets to customize the disabled handling
718 // - disabled as an array instead of boolean
719 // - disabled class as method for disabling individual parts
720 if ( !suppressDisabledCheck &&
721 ( instance.options.disabled === true ||
722 $( this ).hasClass( "ui-state-disabled" ) ) ) {
723 return;
724 }
725 return ( typeof handler === "string" ? instance[ handler ] : handler )
726 .apply( instance, arguments );
727 }
728
729 // copy the guid so direct unbinding works
730 if ( typeof handler !== "string" ) {
731 handlerProxy.guid = handler.guid =
732 handler.guid || handlerProxy.guid || $.guid++;
733 }
734
735 var match = event.match( /^([\w:-]*)\s*(.*)$/ ),
736 eventName = match[1] + instance.eventNamespace,
737 selector = match[2];
738 if ( selector ) {
739 delegateElement.delegate( selector, eventName, handlerProxy );
740 } else {
741 element.bind( eventName, handlerProxy );
742 }
743 });
744 },
745
746 _off: function( element, eventName ) {
747 eventName = (eventName || "").split( " " ).join( this.eventNamespace + " " ) +
748 this.eventNamespace;
749 element.unbind( eventName ).undelegate( eventName );
750
751 // Clear the stack to avoid memory leaks (#10056)
752 this.bindings = $( this.bindings.not( element ).get() );
753 this.focusable = $( this.focusable.not( element ).get() );
754 this.hoverable = $( this.hoverable.not( element ).get() );
755 },
756
757 _delay: function( handler, delay ) {
758 function handlerProxy() {
759 return ( typeof handler === "string" ? instance[ handler ] : handler )
760 .apply( instance, arguments );
761 }
762 var instance = this;
763 return setTimeout( handlerProxy, delay || 0 );
764 },
765
766 _hoverable: function( element ) {
767 this.hoverable = this.hoverable.add( element );
768 this._on( element, {
769 mouseenter: function( event ) {
770 $( event.currentTarget ).addClass( "ui-state-hover" );
771 },
772 mouseleave: function( event ) {
773 $( event.currentTarget ).removeClass( "ui-state-hover" );
774 }
775 });
776 },
777
778 _focusable: function( element ) {
779 this.focusable = this.focusable.add( element );
780 this._on( element, {
781 focusin: function( event ) {
782 $( event.currentTarget ).addClass( "ui-state-focus" );
783 },
784 focusout: function( event ) {
785 $( event.currentTarget ).removeClass( "ui-state-focus" );
786 }
787 });
788 },
789
790 _trigger: function( type, event, data ) {
791 var prop, orig,
792 callback = this.options[ type ];
793
794 data = data || {};
795 event = $.Event( event );
796 event.type = ( type === this.widgetEventPrefix ?
797 type :
798 this.widgetEventPrefix + type ).toLowerCase();
799 // the original event may come from any element
800 // so we need to reset the target on the new event
801 event.target = this.element[ 0 ];
802
803 // copy original event properties over to the new event
804 orig = event.originalEvent;
805 if ( orig ) {
806 for ( prop in orig ) {
807 if ( !( prop in event ) ) {
808 event[ prop ] = orig[ prop ];
809 }
810 }
811 }
812
813 this.element.trigger( event, data );
814 return !( $.isFunction( callback ) &&
815 callback.apply( this.element[0], [ event ].concat( data ) ) === false ||
816 event.isDefaultPrevented() );
817 }
818 };
819
820 $.each( { show: "fadeIn", hide: "fadeOut" }, function( method, defaultEffect ) {
821 $.Widget.prototype[ "_" + method ] = function( element, options, callback ) {
822 if ( typeof options === "string" ) {
823 options = { effect: options };
824 }
825 var hasOptions,
826 effectName = !options ?
827 method :
828 options === true || typeof options === "number" ?
829 defaultEffect :
830 options.effect || defaultEffect;
831 options = options || {};
832 if ( typeof options === "number" ) {
833 options = { duration: options };
834 }
835 hasOptions = !$.isEmptyObject( options );
836 options.complete = callback;
837 if ( options.delay ) {
838 element.delay( options.delay );
839 }
840 if ( hasOptions && $.effects && $.effects.effect[ effectName ] ) {
841 element[ method ]( options );
842 } else if ( effectName !== method && element[ effectName ] ) {
843 element[ effectName ]( options.duration, options.easing, callback );
844 } else {
845 element.queue(function( next ) {
846 $( this )[ method ]();
847 if ( callback ) {
848 callback.call( element[ 0 ] );
849 }
850 next();
851 });
852 }
853 };
854 });
855
856 var widget = $.widget;
857
858
859 /*!
860 * jQuery UI Mouse 1.11.4
861 * http://jqueryui.com
862 *
863 * Copyright jQuery Foundation and other contributors
864 * Released under the MIT license.
865 * http://jquery.org/license
866 *
867 * http://api.jqueryui.com/mouse/
868 */
869
870
871 var mouseHandled = false;
872 $( document ).mouseup( function() {
873 mouseHandled = false;
874 });
875
876 var mouse = $.widget("ui.mouse", {
877 version: "1.11.4",
878 options: {
879 cancel: "input,textarea,button,select,option",
880 distance: 1,
881 delay: 0
882 },
883 _mouseInit: function() {
884 var that = this;
885
886 this.element
887 .bind("mousedown." + this.widgetName, function(event) {
888 return that._mouseDown(event);
889 })
890 .bind("click." + this.widgetName, function(event) {
891 if (true === $.data(event.target, that.widgetName + ".preventClickEvent")) {
892 $.removeData(event.target, that.widgetName + ".preventClickEvent");
893 event.stopImmediatePropagation();
894 return false;
895 }
896 });
897
898 this.started = false;
899 },
900
901 // TODO: make sure destroying one instance of mouse doesn't mess with
902 // other instances of mouse
903 _mouseDestroy: function() {
904 this.element.unbind("." + this.widgetName);
905 if ( this._mouseMoveDelegate ) {
906 this.document
907 .unbind("mousemove." + this.widgetName, this._mouseMoveDelegate)
908 .unbind("mouseup." + this.widgetName, this._mouseUpDelegate);
909 }
910 },
911
912 _mouseDown: function(event) {
913 // don't let more than one widget handle mouseStart
914 if ( mouseHandled ) {
915 return;
916 }
917
918 this._mouseMoved = false;
919
920 // we may have missed mouseup (out of window)
921 (this._mouseStarted && this._mouseUp(event));
922
923 this._mouseDownEvent = event;
924
925 var that = this,
926 btnIsLeft = (event.which === 1),
927 // event.target.nodeName works around a bug in IE 8 with
928 // disabled inputs (#7620)
929 elIsCancel = (typeof this.options.cancel === "string" && event.target.nodeName ? $(event.target).closest(this.options.cancel).length : false);
930 if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
931 return true;
932 }
933
934 this.mouseDelayMet = !this.options.delay;
935 if (!this.mouseDelayMet) {
936 this._mouseDelayTimer = setTimeout(function() {
937 that.mouseDelayMet = true;
938 }, this.options.delay);
939 }
940
941 if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
942 this._mouseStarted = (this._mouseStart(event) !== false);
943 if (!this._mouseStarted) {
944 event.preventDefault();
945 return true;
946 }
947 }
948
949 // Click event may never have fired (Gecko & Opera)
950 if (true === $.data(event.target, this.widgetName + ".preventClickEvent")) {
951 $.removeData(event.target, this.widgetName + ".preventClickEvent");
952 }
953
954 // these delegates are required to keep context
955 this._mouseMoveDelegate = function(event) {
956 return that._mouseMove(event);
957 };
958 this._mouseUpDelegate = function(event) {
959 return that._mouseUp(event);
960 };
961
962 this.document
963 .bind( "mousemove." + this.widgetName, this._mouseMoveDelegate )
964 .bind( "mouseup." + this.widgetName, this._mouseUpDelegate );
965
966 event.preventDefault();
967
968 mouseHandled = true;
969 return true;
970 },
971
972 _mouseMove: function(event) {
973 // Only check for mouseups outside the document if you've moved inside the document
974 // at least once. This prevents the firing of mouseup in the case of IE<9, which will
975 // fire a mousemove event if content is placed under the cursor. See #7778
976 // Support: IE <9
977 if ( this._mouseMoved ) {
978 // IE mouseup check - mouseup happened when mouse was out of window
979 if ($.ui.ie && ( !document.documentMode || document.documentMode < 9 ) && !event.button) {
980 return this._mouseUp(event);
981
982 // Iframe mouseup check - mouseup occurred in another document
983 } else if ( !event.which ) {
984 return this._mouseUp( event );
985 }
986 }
987
988 if ( event.which || event.button ) {
989 this._mouseMoved = true;
990 }
991
992 if (this._mouseStarted) {
993 this._mouseDrag(event);
994 return event.preventDefault();
995 }
996
997 if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
998 this._mouseStarted =
999 (this._mouseStart(this._mouseDownEvent, event) !== false);
1000 (this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
1001 }
1002
1003 return !this._mouseStarted;
1004 },
1005
1006 _mouseUp: function(event) {
1007 this.document
1008 .unbind( "mousemove." + this.widgetName, this._mouseMoveDelegate )
1009 .unbind( "mouseup." + this.widgetName, this._mouseUpDelegate );
1010
1011 if (this._mouseStarted) {
1012 this._mouseStarted = false;
1013
1014 if (event.target === this._mouseDownEvent.target) {
1015 $.data(event.target, this.widgetName + ".preventClickEvent", true);
1016 }
1017
1018 this._mouseStop(event);
1019 }
1020
1021 mouseHandled = false;
1022 return false;
1023 },
1024
1025 _mouseDistanceMet: function(event) {
1026 return (Math.max(
1027 Math.abs(this._mouseDownEvent.pageX - event.pageX),
1028 Math.abs(this._mouseDownEvent.pageY - event.pageY)
1029 ) >= this.options.distance
1030 );
1031 },
1032
1033 _mouseDelayMet: function(/* event */) {
1034 return this.mouseDelayMet;
1035 },
1036
1037 // These are placeholder methods, to be overriden by extending plugin
1038 _mouseStart: function(/* event */) {},
1039 _mouseDrag: function(/* event */) {},
1040 _mouseStop: function(/* event */) {},
1041 _mouseCapture: function(/* event */) { return true; }
1042 });
1043
1044
1045 /*!
1046 * jQuery UI Position 1.11.4
1047 * http://jqueryui.com
1048 *
1049 * Copyright jQuery Foundation and other contributors
1050 * Released under the MIT license.
1051 * http://jquery.org/license
1052 *
1053 * http://api.jqueryui.com/position/
1054 */
1055
1056 (function() {
1057
1058 $.ui = $.ui || {};
1059
1060 var cachedScrollbarWidth, supportsOffsetFractions,
1061 max = Math.max,
1062 abs = Math.abs,
1063 round = Math.round,
1064 rhorizontal = /left|center|right/,
1065 rvertical = /top|center|bottom/,
1066 roffset = /[\+\-]\d+(\.[\d]+)?%?/,
1067 rposition = /^\w+/,
1068 rpercent = /%$/,
1069 _position = $.fn.position;
1070
1071 function getOffsets( offsets, width, height ) {
1072 return [
1073 parseFloat( offsets[ 0 ] ) * ( rpercent.test( offsets[ 0 ] ) ? width / 100 : 1 ),
1074 parseFloat( offsets[ 1 ] ) * ( rpercent.test( offsets[ 1 ] ) ? height / 100 : 1 )
1075 ];
1076 }
1077
1078 function parseCss( element, property ) {
1079 return parseInt( $.css( element, property ), 10 ) || 0;
1080 }
1081
1082 function getDimensions( elem ) {
1083 var raw = elem[0];
1084 if ( raw.nodeType === 9 ) {
1085 return {
1086 width: elem.width(),
1087 height: elem.height(),
1088 offset: { top: 0, left: 0 }
1089 };
1090 }
1091 if ( $.isWindow( raw ) ) {
1092 return {
1093 width: elem.width(),
1094 height: elem.height(),
1095 offset: { top: elem.scrollTop(), left: elem.scrollLeft() }
1096 };
1097 }
1098 if ( raw.preventDefault ) {
1099 return {
1100 width: 0,
1101 height: 0,
1102 offset: { top: raw.pageY, left: raw.pageX }
1103 };
1104 }
1105 return {
1106 width: elem.outerWidth(),
1107 height: elem.outerHeight(),
1108 offset: elem.offset()
1109 };
1110 }
1111
1112 $.position = {
1113 scrollbarWidth: function() {
1114 if ( cachedScrollbarWidth !== undefined ) {
1115 return cachedScrollbarWidth;
1116 }
1117 var w1, w2,
1118 div = $( "<div style='display:block;position:absolute;width:50px;height:50px;overflow:hidden;'><div style='height:100px;width:auto;'></div></div>" ),
1119 innerDiv = div.children()[0];
1120
1121 $( "body" ).append( div );
1122 w1 = innerDiv.offsetWidth;
1123 div.css( "overflow", "scroll" );
1124
1125 w2 = innerDiv.offsetWidth;
1126
1127 if ( w1 === w2 ) {
1128 w2 = div[0].clientWidth;
1129 }
1130
1131 div.remove();
1132
1133 return (cachedScrollbarWidth = w1 - w2);
1134 },
1135 getScrollInfo: function( within ) {
1136 var overflowX = within.isWindow || within.isDocument ? "" :
1137 within.element.css( "overflow-x" ),
1138 overflowY = within.isWindow || within.isDocument ? "" :
1139 within.element.css( "overflow-y" ),
1140 hasOverflowX = overflowX === "scroll" ||
1141 ( overflowX === "auto" && within.width < within.element[0].scrollWidth ),
1142 hasOverflowY = overflowY === "scroll" ||
1143 ( overflowY === "auto" && within.height < within.element[0].scrollHeight );
1144 return {
1145 width: hasOverflowY ? $.position.scrollbarWidth() : 0,
1146 height: hasOverflowX ? $.position.scrollbarWidth() : 0
1147 };
1148 },
1149 getWithinInfo: function( element ) {
1150 var withinElement = $( element || window ),
1151 isWindow = $.isWindow( withinElement[0] ),
1152 isDocument = !!withinElement[ 0 ] && withinElement[ 0 ].nodeType === 9;
1153 return {
1154 element: withinElement,
1155 isWindow: isWindow,
1156 isDocument: isDocument,
1157 offset: withinElement.offset() || { left: 0, top: 0 },
1158 scrollLeft: withinElement.scrollLeft(),
1159 scrollTop: withinElement.scrollTop(),
1160
1161 // support: jQuery 1.6.x
1162 // jQuery 1.6 doesn't support .outerWidth/Height() on documents or windows
1163 width: isWindow || isDocument ? withinElement.width() : withinElement.outerWidth(),
1164 height: isWindow || isDocument ? withinElement.height() : withinElement.outerHeight()
1165 };
1166 }
1167 };
1168
1169 $.fn.position = function( options ) {
1170 if ( !options || !options.of ) {
1171 return _position.apply( this, arguments );
1172 }
1173
1174 // make a copy, we don't want to modify arguments
1175 options = $.extend( {}, options );
1176
1177 var atOffset, targetWidth, targetHeight, targetOffset, basePosition, dimensions,
1178 target = $( options.of ),
1179 within = $.position.getWithinInfo( options.within ),
1180 scrollInfo = $.position.getScrollInfo( within ),
1181 collision = ( options.collision || "flip" ).split( " " ),
1182 offsets = {};
1183
1184 dimensions = getDimensions( target );
1185 if ( target[0].preventDefault ) {
1186 // force left top to allow flipping
1187 options.at = "left top";
1188 }
1189 targetWidth = dimensions.width;
1190 targetHeight = dimensions.height;
1191 targetOffset = dimensions.offset;
1192 // clone to reuse original targetOffset later
1193 basePosition = $.extend( {}, targetOffset );
1194
1195 // force my and at to have valid horizontal and vertical positions
1196 // if a value is missing or invalid, it will be converted to center
1197 $.each( [ "my", "at" ], function() {
1198 var pos = ( options[ this ] || "" ).split( " " ),
1199 horizontalOffset,
1200 verticalOffset;
1201
1202 if ( pos.length === 1) {
1203 pos = rhorizontal.test( pos[ 0 ] ) ?
1204 pos.concat( [ "center" ] ) :
1205 rvertical.test( pos[ 0 ] ) ?
1206 [ "center" ].concat( pos ) :
1207 [ "center", "center" ];
1208 }
1209 pos[ 0 ] = rhorizontal.test( pos[ 0 ] ) ? pos[ 0 ] : "center";
1210 pos[ 1 ] = rvertical.test( pos[ 1 ] ) ? pos[ 1 ] : "center";
1211
1212 // calculate offsets
1213 horizontalOffset = roffset.exec( pos[ 0 ] );
1214 verticalOffset = roffset.exec( pos[ 1 ] );
1215 offsets[ this ] = [
1216 horizontalOffset ? horizontalOffset[ 0 ] : 0,
1217 verticalOffset ? verticalOffset[ 0 ] : 0
1218 ];
1219
1220 // reduce to just the positions without the offsets
1221 options[ this ] = [
1222 rposition.exec( pos[ 0 ] )[ 0 ],
1223 rposition.exec( pos[ 1 ] )[ 0 ]
1224 ];
1225 });
1226
1227 // normalize collision option
1228 if ( collision.length === 1 ) {
1229 collision[ 1 ] = collision[ 0 ];
1230 }
1231
1232 if ( options.at[ 0 ] === "right" ) {
1233 basePosition.left += targetWidth;
1234 } else if ( options.at[ 0 ] === "center" ) {
1235 basePosition.left += targetWidth / 2;
1236 }
1237
1238 if ( options.at[ 1 ] === "bottom" ) {
1239 basePosition.top += targetHeight;
1240 } else if ( options.at[ 1 ] === "center" ) {
1241 basePosition.top += targetHeight / 2;
1242 }
1243
1244 atOffset = getOffsets( offsets.at, targetWidth, targetHeight );
1245 basePosition.left += atOffset[ 0 ];
1246 basePosition.top += atOffset[ 1 ];
1247
1248 return this.each(function() {
1249 var collisionPosition, using,
1250 elem = $( this ),
1251 elemWidth = elem.outerWidth(),
1252 elemHeight = elem.outerHeight(),
1253 marginLeft = parseCss( this, "marginLeft" ),
1254 marginTop = parseCss( this, "marginTop" ),
1255 collisionWidth = elemWidth + marginLeft + parseCss( this, "marginRight" ) + scrollInfo.width,
1256 collisionHeight = elemHeight + marginTop + parseCss( this, "marginBottom" ) + scrollInfo.height,
1257 position = $.extend( {}, basePosition ),
1258 myOffset = getOffsets( offsets.my, elem.outerWidth(), elem.outerHeight() );
1259
1260 if ( options.my[ 0 ] === "right" ) {
1261 position.left -= elemWidth;
1262 } else if ( options.my[ 0 ] === "center" ) {
1263 position.left -= elemWidth / 2;
1264 }
1265
1266 if ( options.my[ 1 ] === "bottom" ) {
1267 position.top -= elemHeight;
1268 } else if ( options.my[ 1 ] === "center" ) {
1269 position.top -= elemHeight / 2;
1270 }
1271
1272 position.left += myOffset[ 0 ];
1273 position.top += myOffset[ 1 ];
1274
1275 // if the browser doesn't support fractions, then round for consistent results
1276 if ( !supportsOffsetFractions ) {
1277 position.left = round( position.left );
1278 position.top = round( position.top );
1279 }
1280
1281 collisionPosition = {
1282 marginLeft: marginLeft,
1283 marginTop: marginTop
1284 };
1285
1286 $.each( [ "left", "top" ], function( i, dir ) {
1287 if ( $.ui.position[ collision[ i ] ] ) {
1288 $.ui.position[ collision[ i ] ][ dir ]( position, {
1289 targetWidth: targetWidth,
1290 targetHeight: targetHeight,
1291 elemWidth: elemWidth,
1292 elemHeight: elemHeight,
1293 collisionPosition: collisionPosition,
1294 collisionWidth: collisionWidth,
1295 collisionHeight: collisionHeight,
1296 offset: [ atOffset[ 0 ] + myOffset[ 0 ], atOffset [ 1 ] + myOffset[ 1 ] ],
1297 my: options.my,
1298 at: options.at,
1299 within: within,
1300 elem: elem
1301 });
1302 }
1303 });
1304
1305 if ( options.using ) {
1306 // adds feedback as second argument to using callback, if present
1307 using = function( props ) {
1308 var left = targetOffset.left - position.left,
1309 right = left + targetWidth - elemWidth,
1310 top = targetOffset.top - position.top,
1311 bottom = top + targetHeight - elemHeight,
1312 feedback = {
1313 target: {
1314 element: target,
1315 left: targetOffset.left,
1316 top: targetOffset.top,
1317 width: targetWidth,
1318 height: targetHeight
1319 },
1320 element: {
1321 element: elem,
1322 left: position.left,
1323 top: position.top,
1324 width: elemWidth,
1325 height: elemHeight
1326 },
1327 horizontal: right < 0 ? "left" : left > 0 ? "right" : "center",
1328 vertical: bottom < 0 ? "top" : top > 0 ? "bottom" : "middle"
1329 };
1330 if ( targetWidth < elemWidth && abs( left + right ) < targetWidth ) {
1331 feedback.horizontal = "center";
1332 }
1333 if ( targetHeight < elemHeight && abs( top + bottom ) < targetHeight ) {
1334 feedback.vertical = "middle";
1335 }
1336 if ( max( abs( left ), abs( right ) ) > max( abs( top ), abs( bottom ) ) ) {
1337 feedback.important = "horizontal";
1338 } else {
1339 feedback.important = "vertical";
1340 }
1341 options.using.call( this, props, feedback );
1342 };
1343 }
1344
1345 elem.offset( $.extend( position, { using: using } ) );
1346 });
1347 };
1348
1349 $.ui.position = {
1350 fit: {
1351 left: function( position, data ) {
1352 var within = data.within,
1353 withinOffset = within.isWindow ? within.scrollLeft : within.offset.left,
1354 outerWidth = within.width,
1355 collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1356 overLeft = withinOffset - collisionPosLeft,
1357 overRight = collisionPosLeft + data.collisionWidth - outerWidth - withinOffset,
1358 newOverRight;
1359
1360 // element is wider than within
1361 if ( data.collisionWidth > outerWidth ) {
1362 // element is initially over the left side of within
1363 if ( overLeft > 0 && overRight <= 0 ) {
1364 newOverRight = position.left + overLeft + data.collisionWidth - outerWidth - withinOffset;
1365 position.left += overLeft - newOverRight;
1366 // element is initially over right side of within
1367 } else if ( overRight > 0 && overLeft <= 0 ) {
1368 position.left = withinOffset;
1369 // element is initially over both left and right sides of within
1370 } else {
1371 if ( overLeft > overRight ) {
1372 position.left = withinOffset + outerWidth - data.collisionWidth;
1373 } else {
1374 position.left = withinOffset;
1375 }
1376 }
1377 // too far left -> align with left edge
1378 } else if ( overLeft > 0 ) {
1379 position.left += overLeft;
1380 // too far right -> align with right edge
1381 } else if ( overRight > 0 ) {
1382 position.left -= overRight;
1383 // adjust based on position and margin
1384 } else {
1385 position.left = max( position.left - collisionPosLeft, position.left );
1386 }
1387 },
1388 top: function( position, data ) {
1389 var within = data.within,
1390 withinOffset = within.isWindow ? within.scrollTop : within.offset.top,
1391 outerHeight = data.within.height,
1392 collisionPosTop = position.top - data.collisionPosition.marginTop,
1393 overTop = withinOffset - collisionPosTop,
1394 overBottom = collisionPosTop + data.collisionHeight - outerHeight - withinOffset,
1395 newOverBottom;
1396
1397 // element is taller than within
1398 if ( data.collisionHeight > outerHeight ) {
1399 // element is initially over the top of within
1400 if ( overTop > 0 && overBottom <= 0 ) {
1401 newOverBottom = position.top + overTop + data.collisionHeight - outerHeight - withinOffset;
1402 position.top += overTop - newOverBottom;
1403 // element is initially over bottom of within
1404 } else if ( overBottom > 0 && overTop <= 0 ) {
1405 position.top = withinOffset;
1406 // element is initially over both top and bottom of within
1407 } else {
1408 if ( overTop > overBottom ) {
1409 position.top = withinOffset + outerHeight - data.collisionHeight;
1410 } else {
1411 position.top = withinOffset;
1412 }
1413 }
1414 // too far up -> align with top
1415 } else if ( overTop > 0 ) {
1416 position.top += overTop;
1417 // too far down -> align with bottom edge
1418 } else if ( overBottom > 0 ) {
1419 position.top -= overBottom;
1420 // adjust based on position and margin
1421 } else {
1422 position.top = max( position.top - collisionPosTop, position.top );
1423 }
1424 }
1425 },
1426 flip: {
1427 left: function( position, data ) {
1428 var within = data.within,
1429 withinOffset = within.offset.left + within.scrollLeft,
1430 outerWidth = within.width,
1431 offsetLeft = within.isWindow ? within.scrollLeft : within.offset.left,
1432 collisionPosLeft = position.left - data.collisionPosition.marginLeft,
1433 overLeft = collisionPosLeft - offsetLeft,
1434 overRight = collisionPosLeft + data.collisionWidth - outerWidth - offsetLeft,
1435 myOffset = data.my[ 0 ] === "left" ?
1436 -data.elemWidth :
1437 data.my[ 0 ] === "right" ?
1438 data.elemWidth :
1439 0,
1440 atOffset = data.at[ 0 ] === "left" ?
1441 data.targetWidth :
1442 data.at[ 0 ] === "right" ?
1443 -data.targetWidth :
1444 0,
1445 offset = -2 * data.offset[ 0 ],
1446 newOverRight,
1447 newOverLeft;
1448
1449 if ( overLeft < 0 ) {
1450 newOverRight = position.left + myOffset + atOffset + offset + data.collisionWidth - outerWidth - withinOffset;
1451 if ( newOverRight < 0 || newOverRight < abs( overLeft ) ) {
1452 position.left += myOffset + atOffset + offset;
1453 }
1454 } else if ( overRight > 0 ) {
1455 newOverLeft = position.left - data.collisionPosition.marginLeft + myOffset + atOffset + offset - offsetLeft;
1456 if ( newOverLeft > 0 || abs( newOverLeft ) < overRight ) {
1457 position.left += myOffset + atOffset + offset;
1458 }
1459 }
1460 },
1461 top: function( position, data ) {
1462 var within = data.within,
1463 withinOffset = within.offset.top + within.scrollTop,
1464 outerHeight = within.height,
1465 offsetTop = within.isWindow ? within.scrollTop : within.offset.top,
1466 collisionPosTop = position.top - data.collisionPosition.marginTop,
1467 overTop = collisionPosTop - offsetTop,
1468 overBottom = collisionPosTop + data.collisionHeight - outerHeight - offsetTop,
1469 top = data.my[ 1 ] === "top",
1470 myOffset = top ?
1471 -data.elemHeight :
1472 data.my[ 1 ] === "bottom" ?
1473 data.elemHeight :
1474 0,
1475 atOffset = data.at[ 1 ] === "top" ?
1476 data.targetHeight :
1477 data.at[ 1 ] === "bottom" ?
1478 -data.targetHeight :
1479 0,
1480 offset = -2 * data.offset[ 1 ],
1481 newOverTop,
1482 newOverBottom;
1483 if ( overTop < 0 ) {
1484 newOverBottom = position.top + myOffset + atOffset + offset + data.collisionHeight - outerHeight - withinOffset;
1485 if ( newOverBottom < 0 || newOverBottom < abs( overTop ) ) {
1486 position.top += myOffset + atOffset + offset;
1487 }
1488 } else if ( overBottom > 0 ) {
1489 newOverTop = position.top - data.collisionPosition.marginTop + myOffset + atOffset + offset - offsetTop;
1490 if ( newOverTop > 0 || abs( newOverTop ) < overBottom ) {
1491 position.top += myOffset + atOffset + offset;
1492 }
1493 }
1494 }
1495 },
1496 flipfit: {
1497 left: function() {
1498 $.ui.position.flip.left.apply( this, arguments );
1499 $.ui.position.fit.left.apply( this, arguments );
1500 },
1501 top: function() {
1502 $.ui.position.flip.top.apply( this, arguments );
1503 $.ui.position.fit.top.apply( this, arguments );
1504 }
1505 }
1506 };
1507
1508 // fraction support test
1509 (function() {
1510 var testElement, testElementParent, testElementStyle, offsetLeft, i,
1511 body = document.getElementsByTagName( "body" )[ 0 ],
1512 div = document.createElement( "div" );
1513
1514 //Create a "fake body" for testing based on method used in jQuery.support
1515 testElement = document.createElement( body ? "div" : "body" );
1516 testElementStyle = {
1517 visibility: "hidden",
1518 width: 0,
1519 height: 0,
1520 border: 0,
1521 margin: 0,
1522 background: "none"
1523 };
1524 if ( body ) {
1525 $.extend( testElementStyle, {
1526 position: "absolute",
1527 left: "-1000px",
1528 top: "-1000px"
1529 });
1530 }
1531 for ( i in testElementStyle ) {
1532 testElement.style[ i ] = testElementStyle[ i ];
1533 }
1534 testElement.appendChild( div );
1535 testElementParent = body || document.documentElement;
1536 testElementParent.insertBefore( testElement, testElementParent.firstChild );
1537
1538 div.style.cssText = "position: absolute; left: 10.7432222px;";
1539
1540 offsetLeft = $( div ).offset().left;
1541 supportsOffsetFractions = offsetLeft > 10 && offsetLeft < 11;
1542
1543 testElement.innerHTML = "";
1544 testElementParent.removeChild( testElement );
1545 })();
1546
1547 })();
1548
1549 var position = $.ui.position;
1550
1551
1552 /*!
1553 * jQuery UI Accordion 1.11.4
1554 * http://jqueryui.com
1555 *
1556 * Copyright jQuery Foundation and other contributors
1557 * Released under the MIT license.
1558 * http://jquery.org/license
1559 *
1560 * http://api.jqueryui.com/accordion/
1561 */
1562
1563
1564 var accordion = $.widget( "ui.accordion", {
1565 version: "1.11.4",
1566 options: {
1567 active: 0,
1568 animate: {},
1569 collapsible: false,
1570 event: "click",
1571 header: "> li > :first-child,> :not(li):even",
1572 heightStyle: "auto",
1573 icons: {
1574 activeHeader: "ui-icon-triangle-1-s",
1575 header: "ui-icon-triangle-1-e"
1576 },
1577
1578 // callbacks
1579 activate: null,
1580 beforeActivate: null
1581 },
1582
1583 hideProps: {
1584 borderTopWidth: "hide",
1585 borderBottomWidth: "hide",
1586 paddingTop: "hide",
1587 paddingBottom: "hide",
1588 height: "hide"
1589 },
1590
1591 showProps: {
1592 borderTopWidth: "show",
1593 borderBottomWidth: "show",
1594 paddingTop: "show",
1595 paddingBottom: "show",
1596 height: "show"
1597 },
1598
1599 _create: function() {
1600 var options = this.options;
1601 this.prevShow = this.prevHide = $();
1602 this.element.addClass( "ui-accordion ui-widget ui-helper-reset" )
1603 // ARIA
1604 .attr( "role", "tablist" );
1605
1606 // don't allow collapsible: false and active: false / null
1607 if ( !options.collapsible && (options.active === false || options.active == null) ) {
1608 options.active = 0;
1609 }
1610
1611 this._processPanels();
1612 // handle negative values
1613 if ( options.active < 0 ) {
1614 options.active += this.headers.length;
1615 }
1616 this._refresh();
1617 },
1618
1619 _getCreateEventData: function() {
1620 return {
1621 header: this.active,
1622 panel: !this.active.length ? $() : this.active.next()
1623 };
1624 },
1625
1626 _createIcons: function() {
1627 var icons = this.options.icons;
1628 if ( icons ) {
1629 $( "<span>" )
1630 .addClass( "ui-accordion-header-icon ui-icon " + icons.header )
1631 .prependTo( this.headers );
1632 this.active.children( ".ui-accordion-header-icon" )
1633 .removeClass( icons.header )
1634 .addClass( icons.activeHeader );
1635 this.headers.addClass( "ui-accordion-icons" );
1636 }
1637 },
1638
1639 _destroyIcons: function() {
1640 this.headers
1641 .removeClass( "ui-accordion-icons" )
1642 .children( ".ui-accordion-header-icon" )
1643 .remove();
1644 },
1645
1646 _destroy: function() {
1647 var contents;
1648
1649 // clean up main element
1650 this.element
1651 .removeClass( "ui-accordion ui-widget ui-helper-reset" )
1652 .removeAttr( "role" );
1653
1654 // clean up headers
1655 this.headers
1656 .removeClass( "ui-accordion-header ui-accordion-header-active ui-state-default " +
1657 "ui-corner-all ui-state-active ui-state-disabled ui-corner-top" )
1658 .removeAttr( "role" )
1659 .removeAttr( "aria-expanded" )
1660 .removeAttr( "aria-selected" )
1661 .removeAttr( "aria-controls" )
1662 .removeAttr( "tabIndex" )
1663 .removeUniqueId();
1664
1665 this._destroyIcons();
1666
1667 // clean up content panels
1668 contents = this.headers.next()
1669 .removeClass( "ui-helper-reset ui-widget-content ui-corner-bottom " +
1670 "ui-accordion-content ui-accordion-content-active ui-state-disabled" )
1671 .css( "display", "" )
1672 .removeAttr( "role" )
1673 .removeAttr( "aria-hidden" )
1674 .removeAttr( "aria-labelledby" )
1675 .removeUniqueId();
1676
1677 if ( this.options.heightStyle !== "content" ) {
1678 contents.css( "height", "" );
1679 }
1680 },
1681
1682 _setOption: function( key, value ) {
1683 if ( key === "active" ) {
1684 // _activate() will handle invalid values and update this.options
1685 this._activate( value );
1686 return;
1687 }
1688
1689 if ( key === "event" ) {
1690 if ( this.options.event ) {
1691 this._off( this.headers, this.options.event );
1692 }
1693 this._setupEvents( value );
1694 }
1695
1696 this._super( key, value );
1697
1698 // setting collapsible: false while collapsed; open first panel
1699 if ( key === "collapsible" && !value && this.options.active === false ) {
1700 this._activate( 0 );
1701 }
1702
1703 if ( key === "icons" ) {
1704 this._destroyIcons();
1705 if ( value ) {
1706 this._createIcons();
1707 }
1708 }
1709
1710 // #5332 - opacity doesn't cascade to positioned elements in IE
1711 // so we need to add the disabled class to the headers and panels
1712 if ( key === "disabled" ) {
1713 this.element
1714 .toggleClass( "ui-state-disabled", !!value )
1715 .attr( "aria-disabled", value );
1716 this.headers.add( this.headers.next() )
1717 .toggleClass( "ui-state-disabled", !!value );
1718 }
1719 },
1720
1721 _keydown: function( event ) {
1722 if ( event.altKey || event.ctrlKey ) {
1723 return;
1724 }
1725
1726 var keyCode = $.ui.keyCode,
1727 length = this.headers.length,
1728 currentIndex = this.headers.index( event.target ),
1729 toFocus = false;
1730
1731 switch ( event.keyCode ) {
1732 case keyCode.RIGHT:
1733 case keyCode.DOWN:
1734 toFocus = this.headers[ ( currentIndex + 1 ) % length ];
1735 break;
1736 case keyCode.LEFT:
1737 case keyCode.UP:
1738 toFocus = this.headers[ ( currentIndex - 1 + length ) % length ];
1739 break;
1740 case keyCode.SPACE:
1741 case keyCode.ENTER:
1742 this._eventHandler( event );
1743 break;
1744 case keyCode.HOME:
1745 toFocus = this.headers[ 0 ];
1746 break;
1747 case keyCode.END:
1748 toFocus = this.headers[ length - 1 ];
1749 break;
1750 }
1751
1752 if ( toFocus ) {
1753 $( event.target ).attr( "tabIndex", -1 );
1754 $( toFocus ).attr( "tabIndex", 0 );
1755 toFocus.focus();
1756 event.preventDefault();
1757 }
1758 },
1759
1760 _panelKeyDown: function( event ) {
1761 if ( event.keyCode === $.ui.keyCode.UP && event.ctrlKey ) {
1762 $( event.currentTarget ).prev().focus();
1763 }
1764 },
1765
1766 refresh: function() {
1767 var options = this.options;
1768 this._processPanels();
1769
1770 // was collapsed or no panel
1771 if ( ( options.active === false && options.collapsible === true ) || !this.headers.length ) {
1772 options.active = false;
1773 this.active = $();
1774 // active false only when collapsible is true
1775 } else if ( options.active === false ) {
1776 this._activate( 0 );
1777 // was active, but active panel is gone
1778 } else if ( this.active.length && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
1779 // all remaining panel are disabled
1780 if ( this.headers.length === this.headers.find(".ui-state-disabled").length ) {
1781 options.active = false;
1782 this.active = $();
1783 // activate previous panel
1784 } else {
1785 this._activate( Math.max( 0, options.active - 1 ) );
1786 }
1787 // was active, active panel still exists
1788 } else {
1789 // make sure active index is correct
1790 options.active = this.headers.index( this.active );
1791 }
1792
1793 this._destroyIcons();
1794
1795 this._refresh();
1796 },
1797
1798 _processPanels: function() {
1799 var prevHeaders = this.headers,
1800 prevPanels = this.panels;
1801
1802 this.headers = this.element.find( this.options.header )
1803 .addClass( "ui-accordion-header ui-state-default ui-corner-all" );
1804
1805 this.panels = this.headers.next()
1806 .addClass( "ui-accordion-content ui-helper-reset ui-widget-content ui-corner-bottom" )
1807 .filter( ":not(.ui-accordion-content-active)" )
1808 .hide();
1809
1810 // Avoid memory leaks (#10056)
1811 if ( prevPanels ) {
1812 this._off( prevHeaders.not( this.headers ) );
1813 this._off( prevPanels.not( this.panels ) );
1814 }
1815 },
1816
1817 _refresh: function() {
1818 var maxHeight,
1819 options = this.options,
1820 heightStyle = options.heightStyle,
1821 parent = this.element.parent();
1822
1823 this.active = this._findActive( options.active )
1824 .addClass( "ui-accordion-header-active ui-state-active ui-corner-top" )
1825 .removeClass( "ui-corner-all" );
1826 this.active.next()
1827 .addClass( "ui-accordion-content-active" )
1828 .show();
1829
1830 this.headers
1831 .attr( "role", "tab" )
1832 .each(function() {
1833 var header = $( this ),
1834 headerId = header.uniqueId().attr( "id" ),
1835 panel = header.next(),
1836 panelId = panel.uniqueId().attr( "id" );
1837 header.attr( "aria-controls", panelId );
1838 panel.attr( "aria-labelledby", headerId );
1839 })
1840 .next()
1841 .attr( "role", "tabpanel" );
1842
1843 this.headers
1844 .not( this.active )
1845 .attr({
1846 "aria-selected": "false",
1847 "aria-expanded": "false",
1848 tabIndex: -1
1849 })
1850 .next()
1851 .attr({
1852 "aria-hidden": "true"
1853 })
1854 .hide();
1855
1856 // make sure at least one header is in the tab order
1857 if ( !this.active.length ) {
1858 this.headers.eq( 0 ).attr( "tabIndex", 0 );
1859 } else {
1860 this.active.attr({
1861 "aria-selected": "true",
1862 "aria-expanded": "true",
1863 tabIndex: 0
1864 })
1865 .next()
1866 .attr({
1867 "aria-hidden": "false"
1868 });
1869 }
1870
1871 this._createIcons();
1872
1873 this._setupEvents( options.event );
1874
1875 if ( heightStyle === "fill" ) {
1876 maxHeight = parent.height();
1877 this.element.siblings( ":visible" ).each(function() {
1878 var elem = $( this ),
1879 position = elem.css( "position" );
1880
1881 if ( position === "absolute" || position === "fixed" ) {
1882 return;
1883 }
1884 maxHeight -= elem.outerHeight( true );
1885 });
1886
1887 this.headers.each(function() {
1888 maxHeight -= $( this ).outerHeight( true );
1889 });
1890
1891 this.headers.next()
1892 .each(function() {
1893 $( this ).height( Math.max( 0, maxHeight -
1894 $( this ).innerHeight() + $( this ).height() ) );
1895 })
1896 .css( "overflow", "auto" );
1897 } else if ( heightStyle === "auto" ) {
1898 maxHeight = 0;
1899 this.headers.next()
1900 .each(function() {
1901 maxHeight = Math.max( maxHeight, $( this ).css( "height", "" ).height() );
1902 })
1903 .height( maxHeight );
1904 }
1905 },
1906
1907 _activate: function( index ) {
1908 var active = this._findActive( index )[ 0 ];
1909
1910 // trying to activate the already active panel
1911 if ( active === this.active[ 0 ] ) {
1912 return;
1913 }
1914
1915 // trying to collapse, simulate a click on the currently active header
1916 active = active || this.active[ 0 ];
1917
1918 this._eventHandler({
1919 target: active,
1920 currentTarget: active,
1921 preventDefault: $.noop
1922 });
1923 },
1924
1925 _findActive: function( selector ) {
1926 return typeof selector === "number" ? this.headers.eq( selector ) : $();
1927 },
1928
1929 _setupEvents: function( event ) {
1930 var events = {
1931 keydown: "_keydown"
1932 };
1933 if ( event ) {
1934 $.each( event.split( " " ), function( index, eventName ) {
1935 events[ eventName ] = "_eventHandler";
1936 });
1937 }
1938
1939 this._off( this.headers.add( this.headers.next() ) );
1940 this._on( this.headers, events );
1941 this._on( this.headers.next(), { keydown: "_panelKeyDown" });
1942 this._hoverable( this.headers );
1943 this._focusable( this.headers );
1944 },
1945
1946 _eventHandler: function( event ) {
1947 var options = this.options,
1948 active = this.active,
1949 clicked = $( event.currentTarget ),
1950 clickedIsActive = clicked[ 0 ] === active[ 0 ],
1951 collapsing = clickedIsActive && options.collapsible,
1952 toShow = collapsing ? $() : clicked.next(),
1953 toHide = active.next(),
1954 eventData = {
1955 oldHeader: active,
1956 oldPanel: toHide,
1957 newHeader: collapsing ? $() : clicked,
1958 newPanel: toShow
1959 };
1960
1961 event.preventDefault();
1962
1963 if (
1964 // click on active header, but not collapsible
1965 ( clickedIsActive && !options.collapsible ) ||
1966 // allow canceling activation
1967 ( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
1968 return;
1969 }
1970
1971 options.active = collapsing ? false : this.headers.index( clicked );
1972
1973 // when the call to ._toggle() comes after the class changes
1974 // it causes a very odd bug in IE 8 (see #6720)
1975 this.active = clickedIsActive ? $() : clicked;
1976 this._toggle( eventData );
1977
1978 // switch classes
1979 // corner classes on the previously active header stay after the animation
1980 active.removeClass( "ui-accordion-header-active ui-state-active" );
1981 if ( options.icons ) {
1982 active.children( ".ui-accordion-header-icon" )
1983 .removeClass( options.icons.activeHeader )
1984 .addClass( options.icons.header );
1985 }
1986
1987 if ( !clickedIsActive ) {
1988 clicked
1989 .removeClass( "ui-corner-all" )
1990 .addClass( "ui-accordion-header-active ui-state-active ui-corner-top" );
1991 if ( options.icons ) {
1992 clicked.children( ".ui-accordion-header-icon" )
1993 .removeClass( options.icons.header )
1994 .addClass( options.icons.activeHeader );
1995 }
1996
1997 clicked
1998 .next()
1999 .addClass( "ui-accordion-content-active" );
2000 }
2001 },
2002
2003 _toggle: function( data ) {
2004 var toShow = data.newPanel,
2005 toHide = this.prevShow.length ? this.prevShow : data.oldPanel;
2006
2007 // handle activating a panel during the animation for another activation
2008 this.prevShow.add( this.prevHide ).stop( true, true );
2009 this.prevShow = toShow;
2010 this.prevHide = toHide;
2011
2012 if ( this.options.animate ) {
2013 this._animate( toShow, toHide, data );
2014 } else {
2015 toHide.hide();
2016 toShow.show();
2017 this._toggleComplete( data );
2018 }
2019
2020 toHide.attr({
2021 "aria-hidden": "true"
2022 });
2023 toHide.prev().attr({
2024 "aria-selected": "false",
2025 "aria-expanded": "false"
2026 });
2027 // if we're switching panels, remove the old header from the tab order
2028 // if we're opening from collapsed state, remove the previous header from the tab order
2029 // if we're collapsing, then keep the collapsing header in the tab order
2030 if ( toShow.length && toHide.length ) {
2031 toHide.prev().attr({
2032 "tabIndex": -1,
2033 "aria-expanded": "false"
2034 });
2035 } else if ( toShow.length ) {
2036 this.headers.filter(function() {
2037 return parseInt( $( this ).attr( "tabIndex" ), 10 ) === 0;
2038 })
2039 .attr( "tabIndex", -1 );
2040 }
2041
2042 toShow
2043 .attr( "aria-hidden", "false" )
2044 .prev()
2045 .attr({
2046 "aria-selected": "true",
2047 "aria-expanded": "true",
2048 tabIndex: 0
2049 });
2050 },
2051
2052 _animate: function( toShow, toHide, data ) {
2053 var total, easing, duration,
2054 that = this,
2055 adjust = 0,
2056 boxSizing = toShow.css( "box-sizing" ),
2057 down = toShow.length &&
2058 ( !toHide.length || ( toShow.index() < toHide.index() ) ),
2059 animate = this.options.animate || {},
2060 options = down && animate.down || animate,
2061 complete = function() {
2062 that._toggleComplete( data );
2063 };
2064
2065 if ( typeof options === "number" ) {
2066 duration = options;
2067 }
2068 if ( typeof options === "string" ) {
2069 easing = options;
2070 }
2071 // fall back from options to animation in case of partial down settings
2072 easing = easing || options.easing || animate.easing;
2073 duration = duration || options.duration || animate.duration;
2074
2075 if ( !toHide.length ) {
2076 return toShow.animate( this.showProps, duration, easing, complete );
2077 }
2078 if ( !toShow.length ) {
2079 return toHide.animate( this.hideProps, duration, easing, complete );
2080 }
2081
2082 total = toShow.show().outerHeight();
2083 toHide.animate( this.hideProps, {
2084 duration: duration,
2085 easing: easing,
2086 step: function( now, fx ) {
2087 fx.now = Math.round( now );
2088 }
2089 });
2090 toShow
2091 .hide()
2092 .animate( this.showProps, {
2093 duration: duration,
2094 easing: easing,
2095 complete: complete,
2096 step: function( now, fx ) {
2097 fx.now = Math.round( now );
2098 if ( fx.prop !== "height" ) {
2099 if ( boxSizing === "content-box" ) {
2100 adjust += fx.now;
2101 }
2102 } else if ( that.options.heightStyle !== "content" ) {
2103 fx.now = Math.round( total - toHide.outerHeight() - adjust );
2104 adjust = 0;
2105 }
2106 }
2107 });
2108 },
2109
2110 _toggleComplete: function( data ) {
2111 var toHide = data.oldPanel;
2112
2113 toHide
2114 .removeClass( "ui-accordion-content-active" )
2115 .prev()
2116 .removeClass( "ui-corner-top" )
2117 .addClass( "ui-corner-all" );
2118
2119 // Work around for rendering bug in IE (#5421)
2120 if ( toHide.length ) {
2121 toHide.parent()[ 0 ].className = toHide.parent()[ 0 ].className;
2122 }
2123 this._trigger( "activate", null, data );
2124 }
2125 });
2126
2127
2128 /*!
2129 * jQuery UI Menu 1.11.4
2130 * http://jqueryui.com
2131 *
2132 * Copyright jQuery Foundation and other contributors
2133 * Released under the MIT license.
2134 * http://jquery.org/license
2135 *
2136 * http://api.jqueryui.com/menu/
2137 */
2138
2139
2140 var menu = $.widget( "ui.menu", {
2141 version: "1.11.4",
2142 defaultElement: "<ul>",
2143 delay: 300,
2144 options: {
2145 icons: {
2146 submenu: "ui-icon-carat-1-e"
2147 },
2148 items: "> *",
2149 menus: "ul",
2150 position: {
2151 my: "left-1 top",
2152 at: "right top"
2153 },
2154 role: "menu",
2155
2156 // callbacks
2157 blur: null,
2158 focus: null,
2159 select: null
2160 },
2161
2162 _create: function() {
2163 this.activeMenu = this.element;
2164
2165 // Flag used to prevent firing of the click handler
2166 // as the event bubbles up through nested menus
2167 this.mouseHandled = false;
2168 this.element
2169 .uniqueId()
2170 .addClass( "ui-menu ui-widget ui-widget-content" )
2171 .toggleClass( "ui-menu-icons", !!this.element.find( ".ui-icon" ).length )
2172 .attr({
2173 role: this.options.role,
2174 tabIndex: 0
2175 });
2176
2177 if ( this.options.disabled ) {
2178 this.element
2179 .addClass( "ui-state-disabled" )
2180 .attr( "aria-disabled", "true" );
2181 }
2182
2183 this._on({
2184 // Prevent focus from sticking to links inside menu after clicking
2185 // them (focus should always stay on UL during navigation).
2186 "mousedown .ui-menu-item": function( event ) {
2187 event.preventDefault();
2188 },
2189 "click .ui-menu-item": function( event ) {
2190 var target = $( event.target );
2191 if ( !this.mouseHandled && target.not( ".ui-state-disabled" ).length ) {
2192 this.select( event );
2193
2194 // Only set the mouseHandled flag if the event will bubble, see #9469.
2195 if ( !event.isPropagationStopped() ) {
2196 this.mouseHandled = true;
2197 }
2198
2199 // Open submenu on click
2200 if ( target.has( ".ui-menu" ).length ) {
2201 this.expand( event );
2202 } else if ( !this.element.is( ":focus" ) && $( this.document[ 0 ].activeElement ).closest( ".ui-menu" ).length ) {
2203
2204 // Redirect focus to the menu
2205 this.element.trigger( "focus", [ true ] );
2206
2207 // If the active item is on the top level, let it stay active.
2208 // Otherwise, blur the active item since it is no longer visible.
2209 if ( this.active && this.active.parents( ".ui-menu" ).length === 1 ) {
2210 clearTimeout( this.timer );
2211 }
2212 }
2213 }
2214 },
2215 "mouseenter .ui-menu-item": function( event ) {
2216 // Ignore mouse events while typeahead is active, see #10458.
2217 // Prevents focusing the wrong item when typeahead causes a scroll while the mouse
2218 // is over an item in the menu
2219 if ( this.previousFilter ) {
2220 return;
2221 }
2222 var target = $( event.currentTarget );
2223 // Remove ui-state-active class from siblings of the newly focused menu item
2224 // to avoid a jump caused by adjacent elements both having a class with a border
2225 target.siblings( ".ui-state-active" ).removeClass( "ui-state-active" );
2226 this.focus( event, target );
2227 },
2228 mouseleave: "collapseAll",
2229 "mouseleave .ui-menu": "collapseAll",
2230 focus: function( event, keepActiveItem ) {
2231 // If there's already an active item, keep it active
2232 // If not, activate the first item
2233 var item = this.active || this.element.find( this.options.items ).eq( 0 );
2234
2235 if ( !keepActiveItem ) {
2236 this.focus( event, item );
2237 }
2238 },
2239 blur: function( event ) {
2240 this._delay(function() {
2241 if ( !$.contains( this.element[0], this.document[0].activeElement ) ) {
2242 this.collapseAll( event );
2243 }
2244 });
2245 },
2246 keydown: "_keydown"
2247 });
2248
2249 this.refresh();
2250
2251 // Clicks outside of a menu collapse any open menus
2252 this._on( this.document, {
2253 click: function( event ) {
2254 if ( this._closeOnDocumentClick( event ) ) {
2255 this.collapseAll( event );
2256 }
2257
2258 // Reset the mouseHandled flag
2259 this.mouseHandled = false;
2260 }
2261 });
2262 },
2263
2264 _destroy: function() {
2265 // Destroy (sub)menus
2266 this.element
2267 .removeAttr( "aria-activedescendant" )
2268 .find( ".ui-menu" ).addBack()
2269 .removeClass( "ui-menu ui-widget ui-widget-content ui-menu-icons ui-front" )
2270 .removeAttr( "role" )
2271 .removeAttr( "tabIndex" )
2272 .removeAttr( "aria-labelledby" )
2273 .removeAttr( "aria-expanded" )
2274 .removeAttr( "aria-hidden" )
2275 .removeAttr( "aria-disabled" )
2276 .removeUniqueId()
2277 .show();
2278
2279 // Destroy menu items
2280 this.element.find( ".ui-menu-item" )
2281 .removeClass( "ui-menu-item" )
2282 .removeAttr( "role" )
2283 .removeAttr( "aria-disabled" )
2284 .removeUniqueId()
2285 .removeClass( "ui-state-hover" )
2286 .removeAttr( "tabIndex" )
2287 .removeAttr( "role" )
2288 .removeAttr( "aria-haspopup" )
2289 .children().each( function() {
2290 var elem = $( this );
2291 if ( elem.data( "ui-menu-submenu-carat" ) ) {
2292 elem.remove();
2293 }
2294 });
2295
2296 // Destroy menu dividers
2297 this.element.find( ".ui-menu-divider" ).removeClass( "ui-menu-divider ui-widget-content" );
2298 },
2299
2300 _keydown: function( event ) {
2301 var match, prev, character, skip,
2302 preventDefault = true;
2303
2304 switch ( event.keyCode ) {
2305 case $.ui.keyCode.PAGE_UP:
2306 this.previousPage( event );
2307 break;
2308 case $.ui.keyCode.PAGE_DOWN:
2309 this.nextPage( event );
2310 break;
2311 case $.ui.keyCode.HOME:
2312 this._move( "first", "first", event );
2313 break;
2314 case $.ui.keyCode.END:
2315 this._move( "last", "last", event );
2316 break;
2317 case $.ui.keyCode.UP:
2318 this.previous( event );
2319 break;
2320 case $.ui.keyCode.DOWN:
2321 this.next( event );
2322 break;
2323 case $.ui.keyCode.LEFT:
2324 this.collapse( event );
2325 break;
2326 case $.ui.keyCode.RIGHT:
2327 if ( this.active && !this.active.is( ".ui-state-disabled" ) ) {
2328 this.expand( event );
2329 }
2330 break;
2331 case $.ui.keyCode.ENTER:
2332 case $.ui.keyCode.SPACE:
2333 this._activate( event );
2334 break;
2335 case $.ui.keyCode.ESCAPE:
2336 this.collapse( event );
2337 break;
2338 default:
2339 preventDefault = false;
2340 prev = this.previousFilter || "";
2341 character = String.fromCharCode( event.keyCode );
2342 skip = false;
2343
2344 clearTimeout( this.filterTimer );
2345
2346 if ( character === prev ) {
2347 skip = true;
2348 } else {
2349 character = prev + character;
2350 }
2351
2352 match = this._filterMenuItems( character );
2353 match = skip && match.index( this.active.next() ) !== -1 ?
2354 this.active.nextAll( ".ui-menu-item" ) :
2355 match;
2356
2357 // If no matches on the current filter, reset to the last character pressed
2358 // to move down the menu to the first item that starts with that character
2359 if ( !match.length ) {
2360 character = String.fromCharCode( event.keyCode );
2361 match = this._filterMenuItems( character );
2362 }
2363
2364 if ( match.length ) {
2365 this.focus( event, match );
2366 this.previousFilter = character;
2367 this.filterTimer = this._delay(function() {
2368 delete this.previousFilter;
2369 }, 1000 );
2370 } else {
2371 delete this.previousFilter;
2372 }
2373 }
2374
2375 if ( preventDefault ) {
2376 event.preventDefault();
2377 }
2378 },
2379
2380 _activate: function( event ) {
2381 if ( !this.active.is( ".ui-state-disabled" ) ) {
2382 if ( this.active.is( "[aria-haspopup='true']" ) ) {
2383 this.expand( event );
2384 } else {
2385 this.select( event );
2386 }
2387 }
2388 },
2389
2390 refresh: function() {
2391 var menus, items,
2392 that = this,
2393 icon = this.options.icons.submenu,
2394 submenus = this.element.find( this.options.menus );
2395
2396 this.element.toggleClass( "ui-menu-icons", !!this.element.find( ".ui-icon" ).length );
2397
2398 // Initialize nested menus
2399 submenus.filter( ":not(.ui-menu)" )
2400 .addClass( "ui-menu ui-widget ui-widget-content ui-front" )
2401 .hide()
2402 .attr({
2403 role: this.options.role,
2404 "aria-hidden": "true",
2405 "aria-expanded": "false"
2406 })
2407 .each(function() {
2408 var menu = $( this ),
2409 item = menu.parent(),
2410 submenuCarat = $( "<span>" )
2411 .addClass( "ui-menu-icon ui-icon " + icon )
2412 .data( "ui-menu-submenu-carat", true );
2413
2414 item
2415 .attr( "aria-haspopup", "true" )
2416 .prepend( submenuCarat );
2417 menu.attr( "aria-labelledby", item.attr( "id" ) );
2418 });
2419
2420 menus = submenus.add( this.element );
2421 items = menus.find( this.options.items );
2422
2423 // Initialize menu-items containing spaces and/or dashes only as dividers
2424 items.not( ".ui-menu-item" ).each(function() {
2425 var item = $( this );
2426 if ( that._isDivider( item ) ) {
2427 item.addClass( "ui-widget-content ui-menu-divider" );
2428 }
2429 });
2430
2431 // Don't refresh list items that are already adapted
2432 items.not( ".ui-menu-item, .ui-menu-divider" )
2433 .addClass( "ui-menu-item" )
2434 .uniqueId()
2435 .attr({
2436 tabIndex: -1,
2437 role: this._itemRole()
2438 });
2439
2440 // Add aria-disabled attribute to any disabled menu item
2441 items.filter( ".ui-state-disabled" ).attr( "aria-disabled", "true" );
2442
2443 // If the active item has been removed, blur the menu
2444 if ( this.active && !$.contains( this.element[ 0 ], this.active[ 0 ] ) ) {
2445 this.blur();
2446 }
2447 },
2448
2449 _itemRole: function() {
2450 return {
2451 menu: "menuitem",
2452 listbox: "option"
2453 }[ this.options.role ];
2454 },
2455
2456 _setOption: function( key, value ) {
2457 if ( key === "icons" ) {
2458 this.element.find( ".ui-menu-icon" )
2459 .removeClass( this.options.icons.submenu )
2460 .addClass( value.submenu );
2461 }
2462 if ( key === "disabled" ) {
2463 this.element
2464 .toggleClass( "ui-state-disabled", !!value )
2465 .attr( "aria-disabled", value );
2466 }
2467 this._super( key, value );
2468 },
2469
2470 focus: function( event, item ) {
2471 var nested, focused;
2472 this.blur( event, event && event.type === "focus" );
2473
2474 this._scrollIntoView( item );
2475
2476 this.active = item.first();
2477 focused = this.active.addClass( "ui-state-focus" ).removeClass( "ui-state-active" );
2478 // Only update aria-activedescendant if there's a role
2479 // otherwise we assume focus is managed elsewhere
2480 if ( this.options.role ) {
2481 this.element.attr( "aria-activedescendant", focused.attr( "id" ) );
2482 }
2483
2484 // Highlight active parent menu item, if any
2485 this.active
2486 .parent()
2487 .closest( ".ui-menu-item" )
2488 .addClass( "ui-state-active" );
2489
2490 if ( event && event.type === "keydown" ) {
2491 this._close();
2492 } else {
2493 this.timer = this._delay(function() {
2494 this._close();
2495 }, this.delay );
2496 }
2497
2498 nested = item.children( ".ui-menu" );
2499 if ( nested.length && event && ( /^mouse/.test( event.type ) ) ) {
2500 this._startOpening(nested);
2501 }
2502 this.activeMenu = item.parent();
2503
2504 this._trigger( "focus", event, { item: item } );
2505 },
2506
2507 _scrollIntoView: function( item ) {
2508 var borderTop, paddingTop, offset, scroll, elementHeight, itemHeight;
2509 if ( this._hasScroll() ) {
2510 borderTop = parseFloat( $.css( this.activeMenu[0], "borderTopWidth" ) ) || 0;
2511 paddingTop = parseFloat( $.css( this.activeMenu[0], "paddingTop" ) ) || 0;
2512 offset = item.offset().top - this.activeMenu.offset().top - borderTop - paddingTop;
2513 scroll = this.activeMenu.scrollTop();
2514 elementHeight = this.activeMenu.height();
2515 itemHeight = item.outerHeight();
2516
2517 if ( offset < 0 ) {
2518 this.activeMenu.scrollTop( scroll + offset );
2519 } else if ( offset + itemHeight > elementHeight ) {
2520 this.activeMenu.scrollTop( scroll + offset - elementHeight + itemHeight );
2521 }
2522 }
2523 },
2524
2525 blur: function( event, fromFocus ) {
2526 if ( !fromFocus ) {
2527 clearTimeout( this.timer );
2528 }
2529
2530 if ( !this.active ) {
2531 return;
2532 }
2533
2534 this.active.removeClass( "ui-state-focus" );
2535 this.active = null;
2536
2537 this._trigger( "blur", event, { item: this.active } );
2538 },
2539
2540 _startOpening: function( submenu ) {
2541 clearTimeout( this.timer );
2542
2543 // Don't open if already open fixes a Firefox bug that caused a .5 pixel
2544 // shift in the submenu position when mousing over the carat icon
2545 if ( submenu.attr( "aria-hidden" ) !== "true" ) {
2546 return;
2547 }
2548
2549 this.timer = this._delay(function() {
2550 this._close();
2551 this._open( submenu );
2552 }, this.delay );
2553 },
2554
2555 _open: function( submenu ) {
2556 var position = $.extend({
2557 of: this.active
2558 }, this.options.position );
2559
2560 clearTimeout( this.timer );
2561 this.element.find( ".ui-menu" ).not( submenu.parents( ".ui-menu" ) )
2562 .hide()
2563 .attr( "aria-hidden", "true" );
2564
2565 submenu
2566 .show()
2567 .removeAttr( "aria-hidden" )
2568 .attr( "aria-expanded", "true" )
2569 .position( position );
2570 },
2571
2572 collapseAll: function( event, all ) {
2573 clearTimeout( this.timer );
2574 this.timer = this._delay(function() {
2575 // If we were passed an event, look for the submenu that contains the event
2576 var currentMenu = all ? this.element :
2577 $( event && event.target ).closest( this.element.find( ".ui-menu" ) );
2578
2579 // If we found no valid submenu ancestor, use the main menu to close all sub menus anyway
2580 if ( !currentMenu.length ) {
2581 currentMenu = this.element;
2582 }
2583
2584 this._close( currentMenu );
2585
2586 this.blur( event );
2587 this.activeMenu = currentMenu;
2588 }, this.delay );
2589 },
2590
2591 // With no arguments, closes the currently active menu - if nothing is active
2592 // it closes all menus. If passed an argument, it will search for menus BELOW
2593 _close: function( startMenu ) {
2594 if ( !startMenu ) {
2595 startMenu = this.active ? this.active.parent() : this.element;
2596 }
2597
2598 startMenu
2599 .find( ".ui-menu" )
2600 .hide()
2601 .attr( "aria-hidden", "true" )
2602 .attr( "aria-expanded", "false" )
2603 .end()
2604 .find( ".ui-state-active" ).not( ".ui-state-focus" )
2605 .removeClass( "ui-state-active" );
2606 },
2607
2608 _closeOnDocumentClick: function( event ) {
2609 return !$( event.target ).closest( ".ui-menu" ).length;
2610 },
2611
2612 _isDivider: function( item ) {
2613
2614 // Match hyphen, em dash, en dash
2615 return !/[^\-\u2014\u2013\s]/.test( item.text() );
2616 },
2617
2618 collapse: function( event ) {
2619 var newItem = this.active &&
2620 this.active.parent().closest( ".ui-menu-item", this.element );
2621 if ( newItem && newItem.length ) {
2622 this._close();
2623 this.focus( event, newItem );
2624 }
2625 },
2626
2627 expand: function( event ) {
2628 var newItem = this.active &&
2629 this.active
2630 .children( ".ui-menu " )
2631 .find( this.options.items )
2632 .first();
2633
2634 if ( newItem && newItem.length ) {
2635 this._open( newItem.parent() );
2636
2637 // Delay so Firefox will not hide activedescendant change in expanding submenu from AT
2638 this._delay(function() {
2639 this.focus( event, newItem );
2640 });
2641 }
2642 },
2643
2644 next: function( event ) {
2645 this._move( "next", "first", event );
2646 },
2647
2648 previous: function( event ) {
2649 this._move( "prev", "last", event );
2650 },
2651
2652 isFirstItem: function() {
2653 return this.active && !this.active.prevAll( ".ui-menu-item" ).length;
2654 },
2655
2656 isLastItem: function() {
2657 return this.active && !this.active.nextAll( ".ui-menu-item" ).length;
2658 },
2659
2660 _move: function( direction, filter, event ) {
2661 var next;
2662 if ( this.active ) {
2663 if ( direction === "first" || direction === "last" ) {
2664 next = this.active
2665 [ direction === "first" ? "prevAll" : "nextAll" ]( ".ui-menu-item" )
2666 .eq( -1 );
2667 } else {
2668 next = this.active
2669 [ direction + "All" ]( ".ui-menu-item" )
2670 .eq( 0 );
2671 }
2672 }
2673 if ( !next || !next.length || !this.active ) {
2674 next = this.activeMenu.find( this.options.items )[ filter ]();
2675 }
2676
2677 this.focus( event, next );
2678 },
2679
2680 nextPage: function( event ) {
2681 var item, base, height;
2682
2683 if ( !this.active ) {
2684 this.next( event );
2685 return;
2686 }
2687 if ( this.isLastItem() ) {
2688 return;
2689 }
2690 if ( this._hasScroll() ) {
2691 base = this.active.offset().top;
2692 height = this.element.height();
2693 this.active.nextAll( ".ui-menu-item" ).each(function() {
2694 item = $( this );
2695 return item.offset().top - base - height < 0;
2696 });
2697
2698 this.focus( event, item );
2699 } else {
2700 this.focus( event, this.activeMenu.find( this.options.items )
2701 [ !this.active ? "first" : "last" ]() );
2702 }
2703 },
2704
2705 previousPage: function( event ) {
2706 var item, base, height;
2707 if ( !this.active ) {
2708 this.next( event );
2709 return;
2710 }
2711 if ( this.isFirstItem() ) {
2712 return;
2713 }
2714 if ( this._hasScroll() ) {
2715 base = this.active.offset().top;
2716 height = this.element.height();
2717 this.active.prevAll( ".ui-menu-item" ).each(function() {
2718 item = $( this );
2719 return item.offset().top - base + height > 0;
2720 });
2721
2722 this.focus( event, item );
2723 } else {
2724 this.focus( event, this.activeMenu.find( this.options.items ).first() );
2725 }
2726 },
2727
2728 _hasScroll: function() {
2729 return this.element.outerHeight() < this.element.prop( "scrollHeight" );
2730 },
2731
2732 select: function( event ) {
2733 // TODO: It should never be possible to not have an active item at this
2734 // point, but the tests don't trigger mouseenter before click.
2735 this.active = this.active || $( event.target ).closest( ".ui-menu-item" );
2736 var ui = { item: this.active };
2737 if ( !this.active.has( ".ui-menu" ).length ) {
2738 this.collapseAll( event, true );
2739 }
2740 this._trigger( "select", event, ui );
2741 },
2742
2743 _filterMenuItems: function(character) {
2744 var escapedCharacter = character.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" ),
2745 regex = new RegExp( "^" + escapedCharacter, "i" );
2746
2747 return this.activeMenu
2748 .find( this.options.items )
2749
2750 // Only match on items, not dividers or other content (#10571)
2751 .filter( ".ui-menu-item" )
2752 .filter(function() {
2753 return regex.test( $.trim( $( this ).text() ) );
2754 });
2755 }
2756 });
2757
2758
2759 /*!
2760 * jQuery UI Autocomplete 1.11.4
2761 * http://jqueryui.com
2762 *
2763 * Copyright jQuery Foundation and other contributors
2764 * Released under the MIT license.
2765 * http://jquery.org/license
2766 *
2767 * http://api.jqueryui.com/autocomplete/
2768 */
2769
2770
2771 $.widget( "ui.autocomplete", {
2772 version: "1.11.4",
2773 defaultElement: "<input>",
2774 options: {
2775 appendTo: null,
2776 autoFocus: false,
2777 delay: 300,
2778 minLength: 1,
2779 position: {
2780 my: "left top",
2781 at: "left bottom",
2782 collision: "none"
2783 },
2784 source: null,
2785
2786 // callbacks
2787 change: null,
2788 close: null,
2789 focus: null,
2790 open: null,
2791 response: null,
2792 search: null,
2793 select: null
2794 },
2795
2796 requestIndex: 0,
2797 pending: 0,
2798
2799 _create: function() {
2800 // Some browsers only repeat keydown events, not keypress events,
2801 // so we use the suppressKeyPress flag to determine if we've already
2802 // handled the keydown event. #7269
2803 // Unfortunately the code for & in keypress is the same as the up arrow,
2804 // so we use the suppressKeyPressRepeat flag to avoid handling keypress
2805 // events when we know the keydown event was used to modify the
2806 // search term. #7799
2807 var suppressKeyPress, suppressKeyPressRepeat, suppressInput,
2808 nodeName = this.element[ 0 ].nodeName.toLowerCase(),
2809 isTextarea = nodeName === "textarea",
2810 isInput = nodeName === "input";
2811
2812 this.isMultiLine =
2813 // Textareas are always multi-line
2814 isTextarea ? true :
2815 // Inputs are always single-line, even if inside a contentEditable element
2816 // IE also treats inputs as contentEditable
2817 isInput ? false :
2818 // All other element types are determined by whether or not they're contentEditable
2819 this.element.prop( "isContentEditable" );
2820
2821 this.valueMethod = this.element[ isTextarea || isInput ? "val" : "text" ];
2822 this.isNewMenu = true;
2823
2824 this.element
2825 .addClass( "ui-autocomplete-input" )
2826 .attr( "autocomplete", "off" );
2827
2828 this._on( this.element, {
2829 keydown: function( event ) {
2830 if ( this.element.prop( "readOnly" ) ) {
2831 suppressKeyPress = true;
2832 suppressInput = true;
2833 suppressKeyPressRepeat = true;
2834 return;
2835 }
2836
2837 suppressKeyPress = false;
2838 suppressInput = false;
2839 suppressKeyPressRepeat = false;
2840 var keyCode = $.ui.keyCode;
2841 switch ( event.keyCode ) {
2842 case keyCode.PAGE_UP:
2843 suppressKeyPress = true;
2844 this._move( "previousPage", event );
2845 break;
2846 case keyCode.PAGE_DOWN:
2847 suppressKeyPress = true;
2848 this._move( "nextPage", event );
2849 break;
2850 case keyCode.UP:
2851 suppressKeyPress = true;
2852 this._keyEvent( "previous", event );
2853 break;
2854 case keyCode.DOWN:
2855 suppressKeyPress = true;
2856 this._keyEvent( "next", event );
2857 break;
2858 case keyCode.ENTER:
2859 // when menu is open and has focus
2860 if ( this.menu.active ) {
2861 // #6055 - Opera still allows the keypress to occur
2862 // which causes forms to submit
2863 suppressKeyPress = true;
2864 event.preventDefault();
2865 this.menu.select( event );
2866 }
2867 break;
2868 case keyCode.TAB:
2869 if ( this.menu.active ) {
2870 this.menu.select( event );
2871 }
2872 break;
2873 case keyCode.ESCAPE:
2874 if ( this.menu.element.is( ":visible" ) ) {
2875 if ( !this.isMultiLine ) {
2876 this._value( this.term );
2877 }
2878 this.close( event );
2879 // Different browsers have different default behavior for escape
2880 // Single press can mean undo or clear
2881 // Double press in IE means clear the whole form
2882 event.preventDefault();
2883 }
2884 break;
2885 default:
2886 suppressKeyPressRepeat = true;
2887 // search timeout should be triggered before the input value is changed
2888 this._searchTimeout( event );
2889 break;
2890 }
2891 },
2892 keypress: function( event ) {
2893 if ( suppressKeyPress ) {
2894 suppressKeyPress = false;
2895 if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
2896 event.preventDefault();
2897 }
2898 return;
2899 }
2900 if ( suppressKeyPressRepeat ) {
2901 return;
2902 }
2903
2904 // replicate some key handlers to allow them to repeat in Firefox and Opera
2905 var keyCode = $.ui.keyCode;
2906 switch ( event.keyCode ) {
2907 case keyCode.PAGE_UP:
2908 this._move( "previousPage", event );
2909 break;
2910 case keyCode.PAGE_DOWN:
2911 this._move( "nextPage", event );
2912 break;
2913 case keyCode.UP:
2914 this._keyEvent( "previous", event );
2915 break;
2916 case keyCode.DOWN:
2917 this._keyEvent( "next", event );
2918 break;
2919 }
2920 },
2921 input: function( event ) {
2922 if ( suppressInput ) {
2923 suppressInput = false;
2924 event.preventDefault();
2925 return;
2926 }
2927 this._searchTimeout( event );
2928 },
2929 focus: function() {
2930 this.selectedItem = null;
2931 this.previous = this._value();
2932 },
2933 blur: function( event ) {
2934 if ( this.cancelBlur ) {
2935 delete this.cancelBlur;
2936 return;
2937 }
2938
2939 clearTimeout( this.searching );
2940 this.close( event );
2941 this._change( event );
2942 }
2943 });
2944
2945 this._initSource();
2946 this.menu = $( "<ul>" )
2947 .addClass( "ui-autocomplete ui-front" )
2948 .appendTo( this._appendTo() )
2949 .menu({
2950 // disable ARIA support, the live region takes care of that
2951 role: null
2952 })
2953 .hide()
2954 .menu( "instance" );
2955
2956 this._on( this.menu.element, {
2957 mousedown: function( event ) {
2958 // prevent moving focus out of the text field
2959 event.preventDefault();
2960
2961 // IE doesn't prevent moving focus even with event.preventDefault()
2962 // so we set a flag to know when we should ignore the blur event
2963 this.cancelBlur = true;
2964 this._delay(function() {
2965 delete this.cancelBlur;
2966 });
2967
2968 // clicking on the scrollbar causes focus to shift to the body
2969 // but we can't detect a mouseup or a click immediately afterward
2970 // so we have to track the next mousedown and close the menu if
2971 // the user clicks somewhere outside of the autocomplete
2972 var menuElement = this.menu.element[ 0 ];
2973 if ( !$( event.target ).closest( ".ui-menu-item" ).length ) {
2974 this._delay(function() {
2975 var that = this;
2976 this.document.one( "mousedown", function( event ) {
2977 if ( event.target !== that.element[ 0 ] &&
2978 event.target !== menuElement &&
2979 !$.contains( menuElement, event.target ) ) {
2980 that.close();
2981 }
2982 });
2983 });
2984 }
2985 },
2986 menufocus: function( event, ui ) {
2987 var label, item;
2988 // support: Firefox
2989 // Prevent accidental activation of menu items in Firefox (#7024 #9118)
2990 if ( this.isNewMenu ) {
2991 this.isNewMenu = false;
2992 if ( event.originalEvent && /^mouse/.test( event.originalEvent.type ) ) {
2993 this.menu.blur();
2994
2995 this.document.one( "mousemove", function() {
2996 $( event.target ).trigger( event.originalEvent );
2997 });
2998
2999 return;
3000 }
3001 }
3002
3003 item = ui.item.data( "ui-autocomplete-item" );
3004 if ( false !== this._trigger( "focus", event, { item: item } ) ) {
3005 // use value to match what will end up in the input, if it was a key event
3006 if ( event.originalEvent && /^key/.test( event.originalEvent.type ) ) {
3007 this._value( item.value );
3008 }
3009 }
3010
3011 // Announce the value in the liveRegion
3012 label = ui.item.attr( "aria-label" ) || item.value;
3013 if ( label && $.trim( label ).length ) {
3014 this.liveRegion.children().hide();
3015 $( "<div>" ).text( label ).appendTo( this.liveRegion );
3016 }
3017 },
3018 menuselect: function( event, ui ) {
3019 var item = ui.item.data( "ui-autocomplete-item" ),
3020 previous = this.previous;
3021
3022 // only trigger when focus was lost (click on menu)
3023 if ( this.element[ 0 ] !== this.document[ 0 ].activeElement ) {
3024 this.element.focus();
3025 this.previous = previous;
3026 // #6109 - IE triggers two focus events and the second
3027 // is asynchronous, so we need to reset the previous
3028 // term synchronously and asynchronously :-(
3029 this._delay(function() {
3030 this.previous = previous;
3031 this.selectedItem = item;
3032 });
3033 }
3034
3035 if ( false !== this._trigger( "select", event, { item: item } ) ) {
3036 this._value( item.value );
3037 }
3038 // reset the term after the select event
3039 // this allows custom select handling to work properly
3040 this.term = this._value();
3041
3042 this.close( event );
3043 this.selectedItem = item;
3044 }
3045 });
3046
3047 this.liveRegion = $( "<span>", {
3048 role: "status",
3049 "aria-live": "assertive",
3050 "aria-relevant": "additions"
3051 })
3052 .addClass( "ui-helper-hidden-accessible" )
3053 .appendTo( this.document[ 0 ].body );
3054
3055 // turning off autocomplete prevents the browser from remembering the
3056 // value when navigating through history, so we re-enable autocomplete
3057 // if the page is unloaded before the widget is destroyed. #7790
3058 this._on( this.window, {
3059 beforeunload: function() {
3060 this.element.removeAttr( "autocomplete" );
3061 }
3062 });
3063 },
3064
3065 _destroy: function() {
3066 clearTimeout( this.searching );
3067 this.element
3068 .removeClass( "ui-autocomplete-input" )
3069 .removeAttr( "autocomplete" );
3070 this.menu.element.remove();
3071 this.liveRegion.remove();
3072 },
3073
3074 _setOption: function( key, value ) {
3075 this._super( key, value );
3076 if ( key === "source" ) {
3077 this._initSource();
3078 }
3079 if ( key === "appendTo" ) {
3080 this.menu.element.appendTo( this._appendTo() );
3081 }
3082 if ( key === "disabled" && value && this.xhr ) {
3083 this.xhr.abort();
3084 }
3085 },
3086
3087 _appendTo: function() {
3088 var element = this.options.appendTo;
3089
3090 if ( element ) {
3091 element = element.jquery || element.nodeType ?
3092 $( element ) :
3093 this.document.find( element ).eq( 0 );
3094 }
3095
3096 if ( !element || !element[ 0 ] ) {
3097 element = this.element.closest( ".ui-front" );
3098 }
3099
3100 if ( !element.length ) {
3101 element = this.document[ 0 ].body;
3102 }
3103
3104 return element;
3105 },
3106
3107 _initSource: function() {
3108 var array, url,
3109 that = this;
3110 if ( $.isArray( this.options.source ) ) {
3111 array = this.options.source;
3112 this.source = function( request, response ) {
3113 response( $.ui.autocomplete.filter( array, request.term ) );
3114 };
3115 } else if ( typeof this.options.source === "string" ) {
3116 url = this.options.source;
3117 this.source = function( request, response ) {
3118 if ( that.xhr ) {
3119 that.xhr.abort();
3120 }
3121 that.xhr = $.ajax({
3122 url: url,
3123 data: request,
3124 dataType: "json",
3125 success: function( data ) {
3126 response( data );
3127 },
3128 error: function() {
3129 response([]);
3130 }
3131 });
3132 };
3133 } else {
3134 this.source = this.options.source;
3135 }
3136 },
3137
3138 _searchTimeout: function( event ) {
3139 clearTimeout( this.searching );
3140 this.searching = this._delay(function() {
3141
3142 // Search if the value has changed, or if the user retypes the same value (see #7434)
3143 var equalValues = this.term === this._value(),
3144 menuVisible = this.menu.element.is( ":visible" ),
3145 modifierKey = event.altKey || event.ctrlKey || event.metaKey || event.shiftKey;
3146
3147 if ( !equalValues || ( equalValues && !menuVisible && !modifierKey ) ) {
3148 this.selectedItem = null;
3149 this.search( null, event );
3150 }
3151 }, this.options.delay );
3152 },
3153
3154 search: function( value, event ) {
3155 value = value != null ? value : this._value();
3156
3157 // always save the actual value, not the one passed as an argument
3158 this.term = this._value();
3159
3160 if ( value.length < this.options.minLength ) {
3161 return this.close( event );
3162 }
3163
3164 if ( this._trigger( "search", event ) === false ) {
3165 return;
3166 }
3167
3168 return this._search( value );
3169 },
3170
3171 _search: function( value ) {
3172 this.pending++;
3173 this.element.addClass( "ui-autocomplete-loading" );
3174 this.cancelSearch = false;
3175
3176 this.source( { term: value }, this._response() );
3177 },
3178
3179 _response: function() {
3180 var index = ++this.requestIndex;
3181
3182 return $.proxy(function( content ) {
3183 if ( index === this.requestIndex ) {
3184 this.__response( content );
3185 }
3186
3187 this.pending--;
3188 if ( !this.pending ) {
3189 this.element.removeClass( "ui-autocomplete-loading" );
3190 }
3191 }, this );
3192 },
3193
3194 __response: function( content ) {
3195 if ( content ) {
3196 content = this._normalize( content );
3197 }
3198 this._trigger( "response", null, { content: content } );
3199 if ( !this.options.disabled && content && content.length && !this.cancelSearch ) {
3200 this._suggest( content );
3201 this._trigger( "open" );
3202 } else {
3203 // use ._close() instead of .close() so we don't cancel future searches
3204 this._close();
3205 }
3206 },
3207
3208 close: function( event ) {
3209 this.cancelSearch = true;
3210 this._close( event );
3211 },
3212
3213 _close: function( event ) {
3214 if ( this.menu.element.is( ":visible" ) ) {
3215 this.menu.element.hide();
3216 this.menu.blur();
3217 this.isNewMenu = true;
3218 this._trigger( "close", event );
3219 }
3220 },
3221
3222 _change: function( event ) {
3223 if ( this.previous !== this._value() ) {
3224 this._trigger( "change", event, { item: this.selectedItem } );
3225 }
3226 },
3227
3228 _normalize: function( items ) {
3229 // assume all items have the right format when the first item is complete
3230 if ( items.length && items[ 0 ].label && items[ 0 ].value ) {
3231 return items;
3232 }
3233 return $.map( items, function( item ) {
3234 if ( typeof item === "string" ) {
3235 return {
3236 label: item,
3237 value: item
3238 };
3239 }
3240 return $.extend( {}, item, {
3241 label: item.label || item.value,
3242 value: item.value || item.label
3243 });
3244 });
3245 },
3246
3247 _suggest: function( items ) {
3248 var ul = this.menu.element.empty();
3249 this._renderMenu( ul, items );
3250 this.isNewMenu = true;
3251 this.menu.refresh();
3252
3253 // size and position menu
3254 ul.show();
3255 this._resizeMenu();
3256 ul.position( $.extend({
3257 of: this.element
3258 }, this.options.position ) );
3259
3260 if ( this.options.autoFocus ) {
3261 this.menu.next();
3262 }
3263 },
3264
3265 _resizeMenu: function() {
3266 var ul = this.menu.element;
3267 ul.outerWidth( Math.max(
3268 // Firefox wraps long text (possibly a rounding bug)
3269 // so we add 1px to avoid the wrapping (#7513)
3270 ul.width( "" ).outerWidth() + 1,
3271 this.element.outerWidth()
3272 ) );
3273 },
3274
3275 _renderMenu: function( ul, items ) {
3276 var that = this;
3277 $.each( items, function( index, item ) {
3278 that._renderItemData( ul, item );
3279 });
3280 },
3281
3282 _renderItemData: function( ul, item ) {
3283 return this._renderItem( ul, item ).data( "ui-autocomplete-item", item );
3284 },
3285
3286 _renderItem: function( ul, item ) {
3287 return $( "<li>" ).text( item.label ).appendTo( ul );
3288 },
3289
3290 _move: function( direction, event ) {
3291 if ( !this.menu.element.is( ":visible" ) ) {
3292 this.search( null, event );
3293 return;
3294 }
3295 if ( this.menu.isFirstItem() && /^previous/.test( direction ) ||
3296 this.menu.isLastItem() && /^next/.test( direction ) ) {
3297
3298 if ( !this.isMultiLine ) {
3299 this._value( this.term );
3300 }
3301
3302 this.menu.blur();
3303 return;
3304 }
3305 this.menu[ direction ]( event );
3306 },
3307
3308 widget: function() {
3309 return this.menu.element;
3310 },
3311
3312 _value: function() {
3313 return this.valueMethod.apply( this.element, arguments );
3314 },
3315
3316 _keyEvent: function( keyEvent, event ) {
3317 if ( !this.isMultiLine || this.menu.element.is( ":visible" ) ) {
3318 this._move( keyEvent, event );
3319
3320 // prevents moving cursor to beginning/end of the text field in some browsers
3321 event.preventDefault();
3322 }
3323 }
3324 });
3325
3326 $.extend( $.ui.autocomplete, {
3327 escapeRegex: function( value ) {
3328 return value.replace( /[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&" );
3329 },
3330 filter: function( array, term ) {
3331 var matcher = new RegExp( $.ui.autocomplete.escapeRegex( term ), "i" );
3332 return $.grep( array, function( value ) {
3333 return matcher.test( value.label || value.value || value );
3334 });
3335 }
3336 });
3337
3338 // live region extension, adding a `messages` option
3339 // NOTE: This is an experimental API. We are still investigating
3340 // a full solution for string manipulation and internationalization.
3341 $.widget( "ui.autocomplete", $.ui.autocomplete, {
3342 options: {
3343 messages: {
3344 noResults: "No search results.",
3345 results: function( amount ) {
3346 return amount + ( amount > 1 ? " results are" : " result is" ) +
3347 " available, use up and down arrow keys to navigate.";
3348 }
3349 }
3350 },
3351
3352 __response: function( content ) {
3353 var message;
3354 this._superApply( arguments );
3355 if ( this.options.disabled || this.cancelSearch ) {
3356 return;
3357 }
3358 if ( content && content.length ) {
3359 message = this.options.messages.results( content.length );
3360 } else {
3361 message = this.options.messages.noResults;
3362 }
3363 this.liveRegion.children().hide();
3364 $( "<div>" ).text( message ).appendTo( this.liveRegion );
3365 }
3366 });
3367
3368 var autocomplete = $.ui.autocomplete;
3369
3370
3371 /*!
3372 * jQuery UI Button 1.11.4
3373 * http://jqueryui.com
3374 *
3375 * Copyright jQuery Foundation and other contributors
3376 * Released under the MIT license.
3377 * http://jquery.org/license
3378 *
3379 * http://api.jqueryui.com/button/
3380 */
3381
3382
3383 var lastActive,
3384 baseClasses = "ui-button ui-widget ui-state-default ui-corner-all",
3385 typeClasses = "ui-button-icons-only ui-button-icon-only ui-button-text-icons ui-button-text-icon-primary ui-button-text-icon-secondary ui-button-text-only",
3386 formResetHandler = function() {
3387 var form = $( this );
3388 setTimeout(function() {
3389 form.find( ":ui-button" ).button( "refresh" );
3390 }, 1 );
3391 },
3392 radioGroup = function( radio ) {
3393 var name = radio.name,
3394 form = radio.form,
3395 radios = $( [] );
3396 if ( name ) {
3397 name = name.replace( /'/g, "\\'" );
3398 if ( form ) {
3399 radios = $( form ).find( "[name='" + name + "'][type=radio]" );
3400 } else {
3401 radios = $( "[name='" + name + "'][type=radio]", radio.ownerDocument )
3402 .filter(function() {
3403 return !this.form;
3404 });
3405 }
3406 }
3407 return radios;
3408 };
3409
3410 $.widget( "ui.button", {
3411 version: "1.11.4",
3412 defaultElement: "<button>",
3413 options: {
3414 disabled: null,
3415 text: true,
3416 label: null,
3417 icons: {
3418 primary: null,
3419 secondary: null
3420 }
3421 },
3422 _create: function() {
3423 this.element.closest( "form" )
3424 .unbind( "reset" + this.eventNamespace )
3425 .bind( "reset" + this.eventNamespace, formResetHandler );
3426
3427 if ( typeof this.options.disabled !== "boolean" ) {
3428 this.options.disabled = !!this.element.prop( "disabled" );
3429 } else {
3430 this.element.prop( "disabled", this.options.disabled );
3431 }
3432
3433 this._determineButtonType();
3434 this.hasTitle = !!this.buttonElement.attr( "title" );
3435
3436 var that = this,
3437 options = this.options,
3438 toggleButton = this.type === "checkbox" || this.type === "radio",
3439 activeClass = !toggleButton ? "ui-state-active" : "";
3440
3441 if ( options.label === null ) {
3442 options.label = (this.type === "input" ? this.buttonElement.val() : this.buttonElement.html());
3443 }
3444
3445 this._hoverable( this.buttonElement );
3446
3447 this.buttonElement
3448 .addClass( baseClasses )
3449 .attr( "role", "button" )
3450 .bind( "mouseenter" + this.eventNamespace, function() {
3451 if ( options.disabled ) {
3452 return;
3453 }
3454 if ( this === lastActive ) {
3455 $( this ).addClass( "ui-state-active" );
3456 }
3457 })
3458 .bind( "mouseleave" + this.eventNamespace, function() {
3459 if ( options.disabled ) {
3460 return;
3461 }
3462 $( this ).removeClass( activeClass );
3463 })
3464 .bind( "click" + this.eventNamespace, function( event ) {
3465 if ( options.disabled ) {
3466 event.preventDefault();
3467 event.stopImmediatePropagation();
3468 }
3469 });
3470
3471 // Can't use _focusable() because the element that receives focus
3472 // and the element that gets the ui-state-focus class are different
3473 this._on({
3474 focus: function() {
3475 this.buttonElement.addClass( "ui-state-focus" );
3476 },
3477 blur: function() {
3478 this.buttonElement.removeClass( "ui-state-focus" );
3479 }
3480 });
3481
3482 if ( toggleButton ) {
3483 this.element.bind( "change" + this.eventNamespace, function() {
3484 that.refresh();
3485 });
3486 }
3487
3488 if ( this.type === "checkbox" ) {
3489 this.buttonElement.bind( "click" + this.eventNamespace, function() {
3490 if ( options.disabled ) {
3491 return false;
3492 }
3493 });
3494 } else if ( this.type === "radio" ) {
3495 this.buttonElement.bind( "click" + this.eventNamespace, function() {
3496 if ( options.disabled ) {
3497 return false;
3498 }
3499 $( this ).addClass( "ui-state-active" );
3500 that.buttonElement.attr( "aria-pressed", "true" );
3501
3502 var radio = that.element[ 0 ];
3503 radioGroup( radio )
3504 .not( radio )
3505 .map(function() {
3506 return $( this ).button( "widget" )[ 0 ];
3507 })
3508 .removeClass( "ui-state-active" )
3509 .attr( "aria-pressed", "false" );
3510 });
3511 } else {
3512 this.buttonElement
3513 .bind( "mousedown" + this.eventNamespace, function() {
3514 if ( options.disabled ) {
3515 return false;
3516 }
3517 $( this ).addClass( "ui-state-active" );
3518 lastActive = this;
3519 that.document.one( "mouseup", function() {
3520 lastActive = null;
3521 });
3522 })
3523 .bind( "mouseup" + this.eventNamespace, function() {
3524 if ( options.disabled ) {
3525 return false;
3526 }
3527 $( this ).removeClass( "ui-state-active" );
3528 })
3529 .bind( "keydown" + this.eventNamespace, function(event) {
3530 if ( options.disabled ) {
3531 return false;
3532 }
3533 if ( event.keyCode === $.ui.keyCode.SPACE || event.keyCode === $.ui.keyCode.ENTER ) {
3534 $( this ).addClass( "ui-state-active" );
3535 }
3536 })
3537 // see #8559, we bind to blur here in case the button element loses
3538 // focus between keydown and keyup, it would be left in an "active" state
3539 .bind( "keyup" + this.eventNamespace + " blur" + this.eventNamespace, function() {
3540 $( this ).removeClass( "ui-state-active" );
3541 });
3542
3543 if ( this.buttonElement.is("a") ) {
3544 this.buttonElement.keyup(function(event) {
3545 if ( event.keyCode === $.ui.keyCode.SPACE ) {
3546 // TODO pass through original event correctly (just as 2nd argument doesn't work)
3547 $( this ).click();
3548 }
3549 });
3550 }
3551 }
3552
3553 this._setOption( "disabled", options.disabled );
3554 this._resetButton();
3555 },
3556
3557 _determineButtonType: function() {
3558 var ancestor, labelSelector, checked;
3559
3560 if ( this.element.is("[type=checkbox]") ) {
3561 this.type = "checkbox";
3562 } else if ( this.element.is("[type=radio]") ) {
3563 this.type = "radio";
3564 } else if ( this.element.is("input") ) {
3565 this.type = "input";
3566 } else {
3567 this.type = "button";
3568 }
3569
3570 if ( this.type === "checkbox" || this.type === "radio" ) {
3571 // we don't search against the document in case the element
3572 // is disconnected from the DOM
3573 ancestor = this.element.parents().last();
3574 labelSelector = "label[for='" + this.element.attr("id") + "']";
3575 this.buttonElement = ancestor.find( labelSelector );
3576 if ( !this.buttonElement.length ) {
3577 ancestor = ancestor.length ? ancestor.siblings() : this.element.siblings();
3578 this.buttonElement = ancestor.filter( labelSelector );
3579 if ( !this.buttonElement.length ) {
3580 this.buttonElement = ancestor.find( labelSelector );
3581 }
3582 }
3583 this.element.addClass( "ui-helper-hidden-accessible" );
3584
3585 checked = this.element.is( ":checked" );
3586 if ( checked ) {
3587 this.buttonElement.addClass( "ui-state-active" );
3588 }
3589 this.buttonElement.prop( "aria-pressed", checked );
3590 } else {
3591 this.buttonElement = this.element;
3592 }
3593 },
3594
3595 widget: function() {
3596 return this.buttonElement;
3597 },
3598
3599 _destroy: function() {
3600 this.element
3601 .removeClass( "ui-helper-hidden-accessible" );
3602 this.buttonElement
3603 .removeClass( baseClasses + " ui-state-active " + typeClasses )
3604 .removeAttr( "role" )
3605 .removeAttr( "aria-pressed" )
3606 .html( this.buttonElement.find(".ui-button-text").html() );
3607
3608 if ( !this.hasTitle ) {
3609 this.buttonElement.removeAttr( "title" );
3610 }
3611 },
3612
3613 _setOption: function( key, value ) {
3614 this._super( key, value );
3615 if ( key === "disabled" ) {
3616 this.widget().toggleClass( "ui-state-disabled", !!value );
3617 this.element.prop( "disabled", !!value );
3618 if ( value ) {
3619 if ( this.type === "checkbox" || this.type === "radio" ) {
3620 this.buttonElement.removeClass( "ui-state-focus" );
3621 } else {
3622 this.buttonElement.removeClass( "ui-state-focus ui-state-active" );
3623 }
3624 }
3625 return;
3626 }
3627 this._resetButton();
3628 },
3629
3630 refresh: function() {
3631 //See #8237 & #8828
3632 var isDisabled = this.element.is( "input, button" ) ? this.element.is( ":disabled" ) : this.element.hasClass( "ui-button-disabled" );
3633
3634 if ( isDisabled !== this.options.disabled ) {
3635 this._setOption( "disabled", isDisabled );
3636 }
3637 if ( this.type === "radio" ) {
3638 radioGroup( this.element[0] ).each(function() {
3639 if ( $( this ).is( ":checked" ) ) {
3640 $( this ).button( "widget" )
3641 .addClass( "ui-state-active" )
3642 .attr( "aria-pressed", "true" );
3643 } else {
3644 $( this ).button( "widget" )
3645 .removeClass( "ui-state-active" )
3646 .attr( "aria-pressed", "false" );
3647 }
3648 });
3649 } else if ( this.type === "checkbox" ) {
3650 if ( this.element.is( ":checked" ) ) {
3651 this.buttonElement
3652 .addClass( "ui-state-active" )
3653 .attr( "aria-pressed", "true" );
3654 } else {
3655 this.buttonElement
3656 .removeClass( "ui-state-active" )
3657 .attr( "aria-pressed", "false" );
3658 }
3659 }
3660 },
3661
3662 _resetButton: function() {
3663 if ( this.type === "input" ) {
3664 if ( this.options.label ) {
3665 this.element.val( this.options.label );
3666 }
3667 return;
3668 }
3669 var buttonElement = this.buttonElement.removeClass( typeClasses ),
3670 buttonText = $( "<span></span>", this.document[0] )
3671 .addClass( "ui-button-text" )
3672 .html( this.options.label )
3673 .appendTo( buttonElement.empty() )
3674 .text(),
3675 icons = this.options.icons,
3676 multipleIcons = icons.primary && icons.secondary,
3677 buttonClasses = [];
3678
3679 if ( icons.primary || icons.secondary ) {
3680 if ( this.options.text ) {
3681 buttonClasses.push( "ui-button-text-icon" + ( multipleIcons ? "s" : ( icons.primary ? "-primary" : "-secondary" ) ) );
3682 }
3683
3684 if ( icons.primary ) {
3685 buttonElement.prepend( "<span class='ui-button-icon-primary ui-icon " + icons.primary + "'></span>" );
3686 }
3687
3688 if ( icons.secondary ) {
3689 buttonElement.append( "<span class='ui-button-icon-secondary ui-icon " + icons.secondary + "'></span>" );
3690 }
3691
3692 if ( !this.options.text ) {
3693 buttonClasses.push( multipleIcons ? "ui-button-icons-only" : "ui-button-icon-only" );
3694
3695 if ( !this.hasTitle ) {
3696 buttonElement.attr( "title", $.trim( buttonText ) );
3697 }
3698 }
3699 } else {
3700 buttonClasses.push( "ui-button-text-only" );
3701 }
3702 buttonElement.addClass( buttonClasses.join( " " ) );
3703 }
3704 });
3705
3706 $.widget( "ui.buttonset", {
3707 version: "1.11.4",
3708 options: {
3709 items: "button, input[type=button], input[type=submit], input[type=reset], input[type=checkbox], input[type=radio], a, :data(ui-button)"
3710 },
3711
3712 _create: function() {
3713 this.element.addClass( "ui-buttonset" );
3714 },
3715
3716 _init: function() {
3717 this.refresh();
3718 },
3719
3720 _setOption: function( key, value ) {
3721 if ( key === "disabled" ) {
3722 this.buttons.button( "option", key, value );
3723 }
3724
3725 this._super( key, value );
3726 },
3727
3728 refresh: function() {
3729 var rtl = this.element.css( "direction" ) === "rtl",
3730 allButtons = this.element.find( this.options.items ),
3731 existingButtons = allButtons.filter( ":ui-button" );
3732
3733 // Initialize new buttons
3734 allButtons.not( ":ui-button" ).button();
3735
3736 // Refresh existing buttons
3737 existingButtons.button( "refresh" );
3738
3739 this.buttons = allButtons
3740 .map(function() {
3741 return $( this ).button( "widget" )[ 0 ];
3742 })
3743 .removeClass( "ui-corner-all ui-corner-left ui-corner-right" )
3744 .filter( ":first" )
3745 .addClass( rtl ? "ui-corner-right" : "ui-corner-left" )
3746 .end()
3747 .filter( ":last" )
3748 .addClass( rtl ? "ui-corner-left" : "ui-corner-right" )
3749 .end()
3750 .end();
3751 },
3752
3753 _destroy: function() {
3754 this.element.removeClass( "ui-buttonset" );
3755 this.buttons
3756 .map(function() {
3757 return $( this ).button( "widget" )[ 0 ];
3758 })
3759 .removeClass( "ui-corner-left ui-corner-right" )
3760 .end()
3761 .button( "destroy" );
3762 }
3763 });
3764
3765 var button = $.ui.button;
3766
3767
3768 /*!
3769 * jQuery UI Datepicker 1.11.4
3770 * http://jqueryui.com
3771 *
3772 * Copyright jQuery Foundation and other contributors
3773 * Released under the MIT license.
3774 * http://jquery.org/license
3775 *
3776 * http://api.jqueryui.com/datepicker/
3777 */
3778
3779
3780 $.extend($.ui, { datepicker: { version: "1.11.4" } });
3781
3782 var datepicker_instActive;
3783
3784 function datepicker_getZindex( elem ) {
3785 var position, value;
3786 while ( elem.length && elem[ 0 ] !== document ) {
3787 // Ignore z-index if position is set to a value where z-index is ignored by the browser
3788 // This makes behavior of this function consistent across browsers
3789 // WebKit always returns auto if the element is positioned
3790 position = elem.css( "position" );
3791 if ( position === "absolute" || position === "relative" || position === "fixed" ) {
3792 // IE returns 0 when zIndex is not specified
3793 // other browsers return a string
3794 // we ignore the case of nested elements with an explicit value of 0
3795 // <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
3796 value = parseInt( elem.css( "zIndex" ), 10 );
3797 if ( !isNaN( value ) && value !== 0 ) {
3798 return value;
3799 }
3800 }
3801 elem = elem.parent();
3802 }
3803
3804 return 0;
3805 }
3806 /* Date picker manager.
3807 Use the singleton instance of this class, $.datepicker, to interact with the date picker.
3808 Settings for (groups of) date pickers are maintained in an instance object,
3809 allowing multiple different settings on the same page. */
3810
3811 function Datepicker() {
3812 this._curInst = null; // The current instance in use
3813 this._keyEvent = false; // If the last event was a key event
3814 this._disabledInputs = []; // List of date picker inputs that have been disabled
3815 this._datepickerShowing = false; // True if the popup picker is showing , false if not
3816 this._inDialog = false; // True if showing within a "dialog", false if not
3817 this._mainDivId = "ui-datepicker-div"; // The ID of the main datepicker division
3818 this._inlineClass = "ui-datepicker-inline"; // The name of the inline marker class
3819 this._appendClass = "ui-datepicker-append"; // The name of the append marker class
3820 this._triggerClass = "ui-datepicker-trigger"; // The name of the trigger marker class
3821 this._dialogClass = "ui-datepicker-dialog"; // The name of the dialog marker class
3822 this._disableClass = "ui-datepicker-disabled"; // The name of the disabled covering marker class
3823 this._unselectableClass = "ui-datepicker-unselectable"; // The name of the unselectable cell marker class
3824 this._currentClass = "ui-datepicker-current-day"; // The name of the current day marker class
3825 this._dayOverClass = "ui-datepicker-days-cell-over"; // The name of the day hover marker class
3826 this.regional = []; // Available regional settings, indexed by language code
3827 this.regional[""] = { // Default regional settings
3828 closeText: "Done", // Display text for close link
3829 prevText: "Prev", // Display text for previous month link
3830 nextText: "Next", // Display text for next month link
3831 currentText: "Today", // Display text for current month link
3832 monthNames: ["January","February","March","April","May","June",
3833 "July","August","September","October","November","December"], // Names of months for drop-down and formatting
3834 monthNamesShort: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"], // For formatting
3835 dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], // For formatting
3836 dayNamesShort: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"], // For formatting
3837 dayNamesMin: ["Su","Mo","Tu","We","Th","Fr","Sa"], // Column headings for days starting at Sunday
3838 weekHeader: "Wk", // Column header for week of the year
3839 dateFormat: "mm/dd/yy", // See format options on parseDate
3840 firstDay: 0, // The first day of the week, Sun = 0, Mon = 1, ...
3841 isRTL: false, // True if right-to-left language, false if left-to-right
3842 showMonthAfterYear: false, // True if the year select precedes month, false for month then year
3843 yearSuffix: "" // Additional text to append to the year in the month headers
3844 };
3845 this._defaults = { // Global defaults for all the date picker instances
3846 showOn: "focus", // "focus" for popup on focus,
3847 // "button" for trigger button, or "both" for either
3848 showAnim: "fadeIn", // Name of jQuery animation for popup
3849 showOptions: {}, // Options for enhanced animations
3850 defaultDate: null, // Used when field is blank: actual date,
3851 // +/-number for offset from today, null for today
3852 appendText: "", // Display text following the input box, e.g. showing the format
3853 buttonText: "...", // Text for trigger button
3854 buttonImage: "", // URL for trigger button image
3855 buttonImageOnly: false, // True if the image appears alone, false if it appears on a button
3856 hideIfNoPrevNext: false, // True to hide next/previous month links
3857 // if not applicable, false to just disable them
3858 navigationAsDateFormat: false, // True if date formatting applied to prev/today/next links
3859 gotoCurrent: false, // True if today link goes back to current selection instead
3860 changeMonth: false, // True if month can be selected directly, false if only prev/next
3861 changeYear: false, // True if year can be selected directly, false if only prev/next
3862 yearRange: "c-10:c+10", // Range of years to display in drop-down,
3863 // either relative to today's year (-nn:+nn), relative to currently displayed year
3864 // (c-nn:c+nn), absolute (nnnn:nnnn), or a combination of the above (nnnn:-n)
3865 showOtherMonths: false, // True to show dates in other months, false to leave blank
3866 selectOtherMonths: false, // True to allow selection of dates in other months, false for unselectable
3867 showWeek: false, // True to show week of the year, false to not show it
3868 calculateWeek: this.iso8601Week, // How to calculate the week of the year,
3869 // takes a Date and returns the number of the week for it
3870 shortYearCutoff: "+10", // Short year values < this are in the current century,
3871 // > this are in the previous century,
3872 // string value starting with "+" for current year + value
3873 minDate: null, // The earliest selectable date, or null for no limit
3874 maxDate: null, // The latest selectable date, or null for no limit
3875 duration: "fast", // Duration of display/closure
3876 beforeShowDay: null, // Function that takes a date and returns an array with
3877 // [0] = true if selectable, false if not, [1] = custom CSS class name(s) or "",
3878 // [2] = cell title (optional), e.g. $.datepicker.noWeekends
3879 beforeShow: null, // Function that takes an input field and
3880 // returns a set of custom settings for the date picker
3881 onSelect: null, // Define a callback function when a date is selected
3882 onChangeMonthYear: null, // Define a callback function when the month or year is changed
3883 onClose: null, // Define a callback function when the datepicker is closed
3884 numberOfMonths: 1, // Number of months to show at a time
3885 showCurrentAtPos: 0, // The position in multipe months at which to show the current month (starting at 0)
3886 stepMonths: 1, // Number of months to step back/forward
3887 stepBigMonths: 12, // Number of months to step back/forward for the big links
3888 altField: "", // Selector for an alternate field to store selected dates into
3889 altFormat: "", // The date format to use for the alternate field
3890 constrainInput: true, // The input is constrained by the current date format
3891 showButtonPanel: false, // True to show button panel, false to not show it
3892 autoSize: false, // True to size the input for the date format, false to leave as is
3893 disabled: false // The initial disabled state
3894 };
3895 $.extend(this._defaults, this.regional[""]);
3896 this.regional.en = $.extend( true, {}, this.regional[ "" ]);
3897 this.regional[ "en-US" ] = $.extend( true, {}, this.regional.en );
3898 this.dpDiv = datepicker_bindHover($("<div id='" + this._mainDivId + "' class='ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>"));
3899 }
3900
3901 $.extend(Datepicker.prototype, {
3902 /* Class name added to elements to indicate already configured with a date picker. */
3903 markerClassName: "hasDatepicker",
3904
3905 //Keep track of the maximum number of rows displayed (see #7043)
3906 maxRows: 4,
3907
3908 // TODO rename to "widget" when switching to widget factory
3909 _widgetDatepicker: function() {
3910 return this.dpDiv;
3911 },
3912
3913 /* Override the default settings for all instances of the date picker.
3914 * @param settings object - the new settings to use as defaults (anonymous object)
3915 * @return the manager object
3916 */
3917 setDefaults: function(settings) {
3918 datepicker_extendRemove(this._defaults, settings || {});
3919 return this;
3920 },
3921
3922 /* Attach the date picker to a jQuery selection.
3923 * @param target element - the target input field or division or span
3924 * @param settings object - the new settings to use for this date picker instance (anonymous)
3925 */
3926 _attachDatepicker: function(target, settings) {
3927 var nodeName, inline, inst;
3928 nodeName = target.nodeName.toLowerCase();
3929 inline = (nodeName === "div" || nodeName === "span");
3930 if (!target.id) {
3931 this.uuid += 1;
3932 target.id = "dp" + this.uuid;
3933 }
3934 inst = this._newInst($(target), inline);
3935 inst.settings = $.extend({}, settings || {});
3936 if (nodeName === "input") {
3937 this._connectDatepicker(target, inst);
3938 } else if (inline) {
3939 this._inlineDatepicker(target, inst);
3940 }
3941 },
3942
3943 /* Create a new instance object. */
3944 _newInst: function(target, inline) {
3945 var id = target[0].id.replace(/([^A-Za-z0-9_\-])/g, "\\\\$1"); // escape jQuery meta chars
3946 return {id: id, input: target, // associated target
3947 selectedDay: 0, selectedMonth: 0, selectedYear: 0, // current selection
3948 drawMonth: 0, drawYear: 0, // month being drawn
3949 inline: inline, // is datepicker inline or not
3950 dpDiv: (!inline ? this.dpDiv : // presentation div
3951 datepicker_bindHover($("<div class='" + this._inlineClass + " ui-datepicker ui-widget ui-widget-content ui-helper-clearfix ui-corner-all'></div>")))};
3952 },
3953
3954 /* Attach the date picker to an input field. */
3955 _connectDatepicker: function(target, inst) {
3956 var input = $(target);
3957 inst.append = $([]);
3958 inst.trigger = $([]);
3959 if (input.hasClass(this.markerClassName)) {
3960 return;
3961 }
3962 this._attachments(input, inst);
3963 input.addClass(this.markerClassName).keydown(this._doKeyDown).
3964 keypress(this._doKeyPress).keyup(this._doKeyUp);
3965 this._autoSize(inst);
3966 $.data(target, "datepicker", inst);
3967 //If disabled option is true, disable the datepicker once it has been attached to the input (see ticket #5665)
3968 if( inst.settings.disabled ) {
3969 this._disableDatepicker( target );
3970 }
3971 },
3972
3973 /* Make attachments based on settings. */
3974 _attachments: function(input, inst) {
3975 var showOn, buttonText, buttonImage,
3976 appendText = this._get(inst, "appendText"),
3977 isRTL = this._get(inst, "isRTL");
3978
3979 if (inst.append) {
3980 inst.append.remove();
3981 }
3982 if (appendText) {
3983 inst.append = $("<span class='" + this._appendClass + "'>" + appendText + "</span>");
3984 input[isRTL ? "before" : "after"](inst.append);
3985 }
3986
3987 input.unbind("focus", this._showDatepicker);
3988
3989 if (inst.trigger) {
3990 inst.trigger.remove();
3991 }
3992
3993 showOn = this._get(inst, "showOn");
3994 if (showOn === "focus" || showOn === "both") { // pop-up date picker when in the marked field
3995 input.focus(this._showDatepicker);
3996 }
3997 if (showOn === "button" || showOn === "both") { // pop-up date picker when button clicked
3998 buttonText = this._get(inst, "buttonText");
3999 buttonImage = this._get(inst, "buttonImage");
4000 inst.trigger = $(this._get(inst, "buttonImageOnly") ?
4001 $("<img/>").addClass(this._triggerClass).
4002 attr({ src: buttonImage, alt: buttonText, title: buttonText }) :
4003 $("<button type='button'></button>").addClass(this._triggerClass).
4004 html(!buttonImage ? buttonText : $("<img/>").attr(
4005 { src:buttonImage, alt:buttonText, title:buttonText })));
4006 input[isRTL ? "before" : "after"](inst.trigger);
4007 inst.trigger.click(function() {
4008 if ($.datepicker._datepickerShowing && $.datepicker._lastInput === input[0]) {
4009 $.datepicker._hideDatepicker();
4010 } else if ($.datepicker._datepickerShowing && $.datepicker._lastInput !== input[0]) {
4011 $.datepicker._hideDatepicker();
4012 $.datepicker._showDatepicker(input[0]);
4013 } else {
4014 $.datepicker._showDatepicker(input[0]);
4015 }
4016 return false;
4017 });
4018 }
4019 },
4020
4021 /* Apply the maximum length for the date format. */
4022 _autoSize: function(inst) {
4023 if (this._get(inst, "autoSize") && !inst.inline) {
4024 var findMax, max, maxI, i,
4025 date = new Date(2009, 12 - 1, 20), // Ensure double digits
4026 dateFormat = this._get(inst, "dateFormat");
4027
4028 if (dateFormat.match(/[DM]/)) {
4029 findMax = function(names) {
4030 max = 0;
4031 maxI = 0;
4032 for (i = 0; i < names.length; i++) {
4033 if (names[i].length > max) {
4034 max = names[i].length;
4035 maxI = i;
4036 }
4037 }
4038 return maxI;
4039 };
4040 date.setMonth(findMax(this._get(inst, (dateFormat.match(/MM/) ?
4041 "monthNames" : "monthNamesShort"))));
4042 date.setDate(findMax(this._get(inst, (dateFormat.match(/DD/) ?
4043 "dayNames" : "dayNamesShort"))) + 20 - date.getDay());
4044 }
4045 inst.input.attr("size", this._formatDate(inst, date).length);
4046 }
4047 },
4048
4049 /* Attach an inline date picker to a div. */
4050 _inlineDatepicker: function(target, inst) {
4051 var divSpan = $(target);
4052 if (divSpan.hasClass(this.markerClassName)) {
4053 return;
4054 }
4055 divSpan.addClass(this.markerClassName).append(inst.dpDiv);
4056 $.data(target, "datepicker", inst);
4057 this._setDate(inst, this._getDefaultDate(inst), true);
4058 this._updateDatepicker(inst);
4059 this._updateAlternate(inst);
4060 //If disabled option is true, disable the datepicker before showing it (see ticket #5665)
4061 if( inst.settings.disabled ) {
4062 this._disableDatepicker( target );
4063 }
4064 // Set display:block in place of inst.dpDiv.show() which won't work on disconnected elements
4065 // http://bugs.jqueryui.com/ticket/7552 - A Datepicker created on a detached div has zero height
4066 inst.dpDiv.css( "display", "block" );
4067 },
4068
4069 /* Pop-up the date picker in a "dialog" box.
4070 * @param input element - ignored
4071 * @param date string or Date - the initial date to display
4072 * @param onSelect function - the function to call when a date is selected
4073 * @param settings object - update the dialog date picker instance's settings (anonymous object)
4074 * @param pos int[2] - coordinates for the dialog's position within the screen or
4075 * event - with x/y coordinates or
4076 * leave empty for default (screen centre)
4077 * @return the manager object
4078 */
4079 _dialogDatepicker: function(input, date, onSelect, settings, pos) {
4080 var id, browserWidth, browserHeight, scrollX, scrollY,
4081 inst = this._dialogInst; // internal instance
4082
4083 if (!inst) {
4084 this.uuid += 1;
4085 id = "dp" + this.uuid;
4086 this._dialogInput = $("<input type='text' id='" + id +
4087 "' style='position: absolute; top: -100px; width: 0px;'/>");
4088 this._dialogInput.keydown(this._doKeyDown);
4089 $("body").append(this._dialogInput);
4090 inst = this._dialogInst = this._newInst(this._dialogInput, false);
4091 inst.settings = {};
4092 $.data(this._dialogInput[0], "datepicker", inst);
4093 }
4094 datepicker_extendRemove(inst.settings, settings || {});
4095 date = (date && date.constructor === Date ? this._formatDate(inst, date) : date);
4096 this._dialogInput.val(date);
4097
4098 this._pos = (pos ? (pos.length ? pos : [pos.pageX, pos.pageY]) : null);
4099 if (!this._pos) {
4100 browserWidth = document.documentElement.clientWidth;
4101 browserHeight = document.documentElement.clientHeight;
4102 scrollX = document.documentElement.scrollLeft || document.body.scrollLeft;
4103 scrollY = document.documentElement.scrollTop || document.body.scrollTop;
4104 this._pos = // should use actual width/height below
4105 [(browserWidth / 2) - 100 + scrollX, (browserHeight / 2) - 150 + scrollY];
4106 }
4107
4108 // move input on screen for focus, but hidden behind dialog
4109 this._dialogInput.css("left", (this._pos[0] + 20) + "px").css("top", this._pos[1] + "px");
4110 inst.settings.onSelect = onSelect;
4111 this._inDialog = true;
4112 this.dpDiv.addClass(this._dialogClass);
4113 this._showDatepicker(this._dialogInput[0]);
4114 if ($.blockUI) {
4115 $.blockUI(this.dpDiv);
4116 }
4117 $.data(this._dialogInput[0], "datepicker", inst);
4118 return this;
4119 },
4120
4121 /* Detach a datepicker from its control.
4122 * @param target element - the target input field or division or span
4123 */
4124 _destroyDatepicker: function(target) {
4125 var nodeName,
4126 $target = $(target),
4127 inst = $.data(target, "datepicker");
4128
4129 if (!$target.hasClass(this.markerClassName)) {
4130 return;
4131 }
4132
4133 nodeName = target.nodeName.toLowerCase();
4134 $.removeData(target, "datepicker");
4135 if (nodeName === "input") {
4136 inst.append.remove();
4137 inst.trigger.remove();
4138 $target.removeClass(this.markerClassName).
4139 unbind("focus", this._showDatepicker).
4140 unbind("keydown", this._doKeyDown).
4141 unbind("keypress", this._doKeyPress).
4142 unbind("keyup", this._doKeyUp);
4143 } else if (nodeName === "div" || nodeName === "span") {
4144 $target.removeClass(this.markerClassName).empty();
4145 }
4146
4147 if ( datepicker_instActive === inst ) {
4148 datepicker_instActive = null;
4149 }
4150 },
4151
4152 /* Enable the date picker to a jQuery selection.
4153 * @param target element - the target input field or division or span
4154 */
4155 _enableDatepicker: function(target) {
4156 var nodeName, inline,
4157 $target = $(target),
4158 inst = $.data(target, "datepicker");
4159
4160 if (!$target.hasClass(this.markerClassName)) {
4161 return;
4162 }
4163
4164 nodeName = target.nodeName.toLowerCase();
4165 if (nodeName === "input") {
4166 target.disabled = false;
4167 inst.trigger.filter("button").
4168 each(function() { this.disabled = false; }).end().
4169 filter("img").css({opacity: "1.0", cursor: ""});
4170 } else if (nodeName === "div" || nodeName === "span") {
4171 inline = $target.children("." + this._inlineClass);
4172 inline.children().removeClass("ui-state-disabled");
4173 inline.find("select.ui-datepicker-month, select.ui-datepicker-year").
4174 prop("disabled", false);
4175 }
4176 this._disabledInputs = $.map(this._disabledInputs,
4177 function(value) { return (value === target ? null : value); }); // delete entry
4178 },
4179
4180 /* Disable the date picker to a jQuery selection.
4181 * @param target element - the target input field or division or span
4182 */
4183 _disableDatepicker: function(target) {
4184 var nodeName, inline,
4185 $target = $(target),
4186 inst = $.data(target, "datepicker");
4187
4188 if (!$target.hasClass(this.markerClassName)) {
4189 return;
4190 }
4191
4192 nodeName = target.nodeName.toLowerCase();
4193 if (nodeName === "input") {
4194 target.disabled = true;
4195 inst.trigger.filter("button").
4196 each(function() { this.disabled = true; }).end().
4197 filter("img").css({opacity: "0.5", cursor: "default"});
4198 } else if (nodeName === "div" || nodeName === "span") {
4199 inline = $target.children("." + this._inlineClass);
4200 inline.children().addClass("ui-state-disabled");
4201 inline.find("select.ui-datepicker-month, select.ui-datepicker-year").
4202 prop("disabled", true);
4203 }
4204 this._disabledInputs = $.map(this._disabledInputs,
4205 function(value) { return (value === target ? null : value); }); // delete entry
4206 this._disabledInputs[this._disabledInputs.length] = target;
4207 },
4208
4209 /* Is the first field in a jQuery collection disabled as a datepicker?
4210 * @param target element - the target input field or division or span
4211 * @return boolean - true if disabled, false if enabled
4212 */
4213 _isDisabledDatepicker: function(target) {
4214 if (!target) {
4215 return false;
4216 }
4217 for (var i = 0; i < this._disabledInputs.length; i++) {
4218 if (this._disabledInputs[i] === target) {
4219 return true;
4220 }
4221 }
4222 return false;
4223 },
4224
4225 /* Retrieve the instance data for the target control.
4226 * @param target element - the target input field or division or span
4227 * @return object - the associated instance data
4228 * @throws error if a jQuery problem getting data
4229 */
4230 _getInst: function(target) {
4231 try {
4232 return $.data(target, "datepicker");
4233 }
4234 catch (err) {
4235 throw "Missing instance data for this datepicker";
4236 }
4237 },
4238
4239 /* Update or retrieve the settings for a date picker attached to an input field or division.
4240 * @param target element - the target input field or division or span
4241 * @param name object - the new settings to update or
4242 * string - the name of the setting to change or retrieve,
4243 * when retrieving also "all" for all instance settings or
4244 * "defaults" for all global defaults
4245 * @param value any - the new value for the setting
4246 * (omit if above is an object or to retrieve a value)
4247 */
4248 _optionDatepicker: function(target, name, value) {
4249 var settings, date, minDate, maxDate,
4250 inst = this._getInst(target);
4251
4252 if (arguments.length === 2 && typeof name === "string") {
4253 return (name === "defaults" ? $.extend({}, $.datepicker._defaults) :
4254 (inst ? (name === "all" ? $.extend({}, inst.settings) :
4255 this._get(inst, name)) : null));
4256 }
4257
4258 settings = name || {};
4259 if (typeof name === "string") {
4260 settings = {};
4261 settings[name] = value;
4262 }
4263
4264 if (inst) {
4265 if (this._curInst === inst) {
4266 this._hideDatepicker();
4267 }
4268
4269 date = this._getDateDatepicker(target, true);
4270 minDate = this._getMinMaxDate(inst, "min");
4271 maxDate = this._getMinMaxDate(inst, "max");
4272 datepicker_extendRemove(inst.settings, settings);
4273 // reformat the old minDate/maxDate values if dateFormat changes and a new minDate/maxDate isn't provided
4274 if (minDate !== null && settings.dateFormat !== undefined && settings.minDate === undefined) {
4275 inst.settings.minDate = this._formatDate(inst, minDate);
4276 }
4277 if (maxDate !== null && settings.dateFormat !== undefined && settings.maxDate === undefined) {
4278 inst.settings.maxDate = this._formatDate(inst, maxDate);
4279 }
4280 if ( "disabled" in settings ) {
4281 if ( settings.disabled ) {
4282 this._disableDatepicker(target);
4283 } else {
4284 this._enableDatepicker(target);
4285 }
4286 }
4287 this._attachments($(target), inst);
4288 this._autoSize(inst);
4289 this._setDate(inst, date);
4290 this._updateAlternate(inst);
4291 this._updateDatepicker(inst);
4292 }
4293 },
4294
4295 // change method deprecated
4296 _changeDatepicker: function(target, name, value) {
4297 this._optionDatepicker(target, name, value);
4298 },
4299
4300 /* Redraw the date picker attached to an input field or division.
4301 * @param target element - the target input field or division or span
4302 */
4303 _refreshDatepicker: function(target) {
4304 var inst = this._getInst(target);
4305 if (inst) {
4306 this._updateDatepicker(inst);
4307 }
4308 },
4309
4310 /* Set the dates for a jQuery selection.
4311 * @param target element - the target input field or division or span
4312 * @param date Date - the new date
4313 */
4314 _setDateDatepicker: function(target, date) {
4315 var inst = this._getInst(target);
4316 if (inst) {
4317 this._setDate(inst, date);
4318 this._updateDatepicker(inst);
4319 this._updateAlternate(inst);
4320 }
4321 },
4322
4323 /* Get the date(s) for the first entry in a jQuery selection.
4324 * @param target element - the target input field or division or span
4325 * @param noDefault boolean - true if no default date is to be used
4326 * @return Date - the current date
4327 */
4328 _getDateDatepicker: function(target, noDefault) {
4329 var inst = this._getInst(target);
4330 if (inst && !inst.inline) {
4331 this._setDateFromField(inst, noDefault);
4332 }
4333 return (inst ? this._getDate(inst) : null);
4334 },
4335
4336 /* Handle keystrokes. */
4337 _doKeyDown: function(event) {
4338 var onSelect, dateStr, sel,
4339 inst = $.datepicker._getInst(event.target),
4340 handled = true,
4341 isRTL = inst.dpDiv.is(".ui-datepicker-rtl");
4342
4343 inst._keyEvent = true;
4344 if ($.datepicker._datepickerShowing) {
4345 switch (event.keyCode) {
4346 case 9: $.datepicker._hideDatepicker();
4347 handled = false;
4348 break; // hide on tab out
4349 case 13: sel = $("td." + $.datepicker._dayOverClass + ":not(." +
4350 $.datepicker._currentClass + ")", inst.dpDiv);
4351 if (sel[0]) {
4352 $.datepicker._selectDay(event.target, inst.selectedMonth, inst.selectedYear, sel[0]);
4353 }
4354
4355 onSelect = $.datepicker._get(inst, "onSelect");
4356 if (onSelect) {
4357 dateStr = $.datepicker._formatDate(inst);
4358
4359 // trigger custom callback
4360 onSelect.apply((inst.input ? inst.input[0] : null), [dateStr, inst]);
4361 } else {
4362 $.datepicker._hideDatepicker();
4363 }
4364
4365 return false; // don't submit the form
4366 case 27: $.datepicker._hideDatepicker();
4367 break; // hide on escape
4368 case 33: $.datepicker._adjustDate(event.target, (event.ctrlKey ?
4369 -$.datepicker._get(inst, "stepBigMonths") :
4370 -$.datepicker._get(inst, "stepMonths")), "M");
4371 break; // previous month/year on page up/+ ctrl
4372 case 34: $.datepicker._adjustDate(event.target, (event.ctrlKey ?
4373 +$.datepicker._get(inst, "stepBigMonths") :
4374 +$.datepicker._get(inst, "stepMonths")), "M");
4375 break; // next month/year on page down/+ ctrl
4376 case 35: if (event.ctrlKey || event.metaKey) {
4377 $.datepicker._clearDate(event.target);
4378 }
4379 handled = event.ctrlKey || event.metaKey;
4380 break; // clear on ctrl or command +end
4381 case 36: if (event.ctrlKey || event.metaKey) {
4382 $.datepicker._gotoToday(event.target);
4383 }
4384 handled = event.ctrlKey || event.metaKey;
4385 break; // current on ctrl or command +home
4386 case 37: if (event.ctrlKey || event.metaKey) {
4387 $.datepicker._adjustDate(event.target, (isRTL ? +1 : -1), "D");
4388 }
4389 handled = event.ctrlKey || event.metaKey;
4390 // -1 day on ctrl or command +left
4391 if (event.originalEvent.altKey) {
4392 $.datepicker._adjustDate(event.target, (event.ctrlKey ?
4393 -$.datepicker._get(inst, "stepBigMonths") :
4394 -$.datepicker._get(inst, "stepMonths")), "M");
4395 }
4396 // next month/year on alt +left on Mac
4397 break;
4398 case 38: if (event.ctrlKey || event.metaKey) {
4399 $.datepicker._adjustDate(event.target, -7, "D");
4400 }
4401 handled = event.ctrlKey || event.metaKey;
4402 break; // -1 week on ctrl or command +up
4403 case 39: if (event.ctrlKey || event.metaKey) {
4404 $.datepicker._adjustDate(event.target, (isRTL ? -1 : +1), "D");
4405 }
4406 handled = event.ctrlKey || event.metaKey;
4407 // +1 day on ctrl or command +right
4408 if (event.originalEvent.altKey) {
4409 $.datepicker._adjustDate(event.target, (event.ctrlKey ?
4410 +$.datepicker._get(inst, "stepBigMonths") :
4411 +$.datepicker._get(inst, "stepMonths")), "M");
4412 }
4413 // next month/year on alt +right
4414 break;
4415 case 40: if (event.ctrlKey || event.metaKey) {
4416 $.datepicker._adjustDate(event.target, +7, "D");
4417 }
4418 handled = event.ctrlKey || event.metaKey;
4419 break; // +1 week on ctrl or command +down
4420 default: handled = false;
4421 }
4422 } else if (event.keyCode === 36 && event.ctrlKey) { // display the date picker on ctrl+home
4423 $.datepicker._showDatepicker(this);
4424 } else {
4425 handled = false;
4426 }
4427
4428 if (handled) {
4429 event.preventDefault();
4430 event.stopPropagation();
4431 }
4432 },
4433
4434 /* Filter entered characters - based on date format. */
4435 _doKeyPress: function(event) {
4436 var chars, chr,
4437 inst = $.datepicker._getInst(event.target);
4438
4439 if ($.datepicker._get(inst, "constrainInput")) {
4440 chars = $.datepicker._possibleChars($.datepicker._get(inst, "dateFormat"));
4441 chr = String.fromCharCode(event.charCode == null ? event.keyCode : event.charCode);
4442 return event.ctrlKey || event.metaKey || (chr < " " || !chars || chars.indexOf(chr) > -1);
4443 }
4444 },
4445
4446 /* Synchronise manual entry and field/alternate field. */
4447 _doKeyUp: function(event) {
4448 var date,
4449 inst = $.datepicker._getInst(event.target);
4450
4451 if (inst.input.val() !== inst.lastVal) {
4452 try {
4453 date = $.datepicker.parseDate($.datepicker._get(inst, "dateFormat"),
4454 (inst.input ? inst.input.val() : null),
4455 $.datepicker._getFormatConfig(inst));
4456
4457 if (date) { // only if valid
4458 $.datepicker._setDateFromField(inst);
4459 $.datepicker._updateAlternate(inst);
4460 $.datepicker._updateDatepicker(inst);
4461 }
4462 }
4463 catch (err) {
4464 }
4465 }
4466 return true;
4467 },
4468
4469 /* Pop-up the date picker for a given input field.
4470 * If false returned from beforeShow event handler do not show.
4471 * @param input element - the input field attached to the date picker or
4472 * event - if triggered by focus
4473 */
4474 _showDatepicker: function(input) {
4475 input = input.target || input;
4476 if (input.nodeName.toLowerCase() !== "input") { // find from button/image trigger
4477 input = $("input", input.parentNode)[0];
4478 }
4479
4480 if ($.datepicker._isDisabledDatepicker(input) || $.datepicker._lastInput === input) { // already here
4481 return;
4482 }
4483
4484 var inst, beforeShow, beforeShowSettings, isFixed,
4485 offset, showAnim, duration;
4486
4487 inst = $.datepicker._getInst(input);
4488 if ($.datepicker._curInst && $.datepicker._curInst !== inst) {
4489 $.datepicker._curInst.dpDiv.stop(true, true);
4490 if ( inst && $.datepicker._datepickerShowing ) {
4491 $.datepicker._hideDatepicker( $.datepicker._curInst.input[0] );
4492 }
4493 }
4494
4495 beforeShow = $.datepicker._get(inst, "beforeShow");
4496 beforeShowSettings = beforeShow ? beforeShow.apply(input, [input, inst]) : {};
4497 if(beforeShowSettings === false){
4498 return;
4499 }
4500 datepicker_extendRemove(inst.settings, beforeShowSettings);
4501
4502 inst.lastVal = null;
4503 $.datepicker._lastInput = input;
4504 $.datepicker._setDateFromField(inst);
4505
4506 if ($.datepicker._inDialog) { // hide cursor
4507 input.value = "";
4508 }
4509 if (!$.datepicker._pos) { // position below input
4510 $.datepicker._pos = $.datepicker._findPos(input);
4511 $.datepicker._pos[1] += input.offsetHeight; // add the height
4512 }
4513
4514 isFixed = false;
4515 $(input).parents().each(function() {
4516 isFixed |= $(this).css("position") === "fixed";
4517 return !isFixed;
4518 });
4519
4520 offset = {left: $.datepicker._pos[0], top: $.datepicker._pos[1]};
4521 $.datepicker._pos = null;
4522 //to avoid flashes on Firefox
4523 inst.dpDiv.empty();
4524 // determine sizing offscreen
4525 inst.dpDiv.css({position: "absolute", display: "block", top: "-1000px"});
4526 $.datepicker._updateDatepicker(inst);
4527 // fix width for dynamic number of date pickers
4528 // and adjust position before showing
4529 offset = $.datepicker._checkOffset(inst, offset, isFixed);
4530 inst.dpDiv.css({position: ($.datepicker._inDialog && $.blockUI ?
4531 "static" : (isFixed ? "fixed" : "absolute")), display: "none",
4532 left: offset.left + "px", top: offset.top + "px"});
4533
4534 if (!inst.inline) {
4535 showAnim = $.datepicker._get(inst, "showAnim");
4536 duration = $.datepicker._get(inst, "duration");
4537 inst.dpDiv.css( "z-index", datepicker_getZindex( $( input ) ) + 1 );
4538 $.datepicker._datepickerShowing = true;
4539
4540 if ( $.effects && $.effects.effect[ showAnim ] ) {
4541 inst.dpDiv.show(showAnim, $.datepicker._get(inst, "showOptions"), duration);
4542 } else {
4543 inst.dpDiv[showAnim || "show"](showAnim ? duration : null);
4544 }
4545
4546 if ( $.datepicker._shouldFocusInput( inst ) ) {
4547 inst.input.focus();
4548 }
4549
4550 $.datepicker._curInst = inst;
4551 }
4552 },
4553
4554 /* Generate the date picker content. */
4555 _updateDatepicker: function(inst) {
4556 this.maxRows = 4; //Reset the max number of rows being displayed (see #7043)
4557 datepicker_instActive = inst; // for delegate hover events
4558 inst.dpDiv.empty().append(this._generateHTML(inst));
4559 this._attachHandlers(inst);
4560
4561 var origyearshtml,
4562 numMonths = this._getNumberOfMonths(inst),
4563 cols = numMonths[1],
4564 width = 17,
4565 activeCell = inst.dpDiv.find( "." + this._dayOverClass + " a" );
4566
4567 if ( activeCell.length > 0 ) {
4568 datepicker_handleMouseover.apply( activeCell.get( 0 ) );
4569 }
4570
4571 inst.dpDiv.removeClass("ui-datepicker-multi-2 ui-datepicker-multi-3 ui-datepicker-multi-4").width("");
4572 if (cols > 1) {
4573 inst.dpDiv.addClass("ui-datepicker-multi-" + cols).css("width", (width * cols) + "em");
4574 }
4575 inst.dpDiv[(numMonths[0] !== 1 || numMonths[1] !== 1 ? "add" : "remove") +
4576 "Class"]("ui-datepicker-multi");
4577 inst.dpDiv[(this._get(inst, "isRTL") ? "add" : "remove") +
4578 "Class"]("ui-datepicker-rtl");
4579
4580 if (inst === $.datepicker._curInst && $.datepicker._datepickerShowing && $.datepicker._shouldFocusInput( inst ) ) {
4581 inst.input.focus();
4582 }
4583
4584 // deffered render of the years select (to avoid flashes on Firefox)
4585 if( inst.yearshtml ){
4586 origyearshtml = inst.yearshtml;
4587 setTimeout(function(){
4588 //assure that inst.yearshtml didn't change.
4589 if( origyearshtml === inst.yearshtml && inst.yearshtml ){
4590 inst.dpDiv.find("select.ui-datepicker-year:first").replaceWith(inst.yearshtml);
4591 }
4592 origyearshtml = inst.yearshtml = null;
4593 }, 0);
4594 }
4595 },
4596
4597 // #6694 - don't focus the input if it's already focused
4598 // this breaks the change event in IE
4599 // Support: IE and jQuery <1.9
4600 _shouldFocusInput: function( inst ) {
4601 return inst.input && inst.input.is( ":visible" ) && !inst.input.is( ":disabled" ) && !inst.input.is( ":focus" );
4602 },
4603
4604 /* Check positioning to remain on screen. */
4605 _checkOffset: function(inst, offset, isFixed) {
4606 var dpWidth = inst.dpDiv.outerWidth(),
4607 dpHeight = inst.dpDiv.outerHeight(),
4608 inputWidth = inst.input ? inst.input.outerWidth() : 0,
4609 inputHeight = inst.input ? inst.input.outerHeight() : 0,
4610 viewWidth = document.documentElement.clientWidth + (isFixed ? 0 : $(document).scrollLeft()),
4611 viewHeight = document.documentElement.clientHeight + (isFixed ? 0 : $(document).scrollTop());
4612
4613 offset.left -= (this._get(inst, "isRTL") ? (dpWidth - inputWidth) : 0);
4614 offset.left -= (isFixed && offset.left === inst.input.offset().left) ? $(document).scrollLeft() : 0;
4615 offset.top -= (isFixed && offset.top === (inst.input.offset().top + inputHeight)) ? $(document).scrollTop() : 0;
4616
4617 // now check if datepicker is showing outside window viewport - move to a better place if so.
4618 offset.left -= Math.min(offset.left, (offset.left + dpWidth > viewWidth && viewWidth > dpWidth) ?
4619 Math.abs(offset.left + dpWidth - viewWidth) : 0);
4620 offset.top -= Math.min(offset.top, (offset.top + dpHeight > viewHeight && viewHeight > dpHeight) ?
4621 Math.abs(dpHeight + inputHeight) : 0);
4622
4623 return offset;
4624 },
4625
4626 /* Find an object's position on the screen. */
4627 _findPos: function(obj) {
4628 var position,
4629 inst = this._getInst(obj),
4630 isRTL = this._get(inst, "isRTL");
4631
4632 while (obj && (obj.type === "hidden" || obj.nodeType !== 1 || $.expr.filters.hidden(obj))) {
4633 obj = obj[isRTL ? "previousSibling" : "nextSibling"];
4634 }
4635
4636 position = $(obj).offset();
4637 return [position.left, position.top];
4638 },
4639
4640 /* Hide the date picker from view.
4641 * @param input element - the input field attached to the date picker
4642 */
4643 _hideDatepicker: function(input) {
4644 var showAnim, duration, postProcess, onClose,
4645 inst = this._curInst;
4646
4647 if (!inst || (input && inst !== $.data(input, "datepicker"))) {
4648 return;
4649 }
4650
4651 if (this._datepickerShowing) {
4652 showAnim = this._get(inst, "showAnim");
4653 duration = this._get(inst, "duration");
4654 postProcess = function() {
4655 $.datepicker._tidyDialog(inst);
4656 };
4657
4658 // DEPRECATED: after BC for 1.8.x $.effects[ showAnim ] is not needed
4659 if ( $.effects && ( $.effects.effect[ showAnim ] || $.effects[ showAnim ] ) ) {
4660 inst.dpDiv.hide(showAnim, $.datepicker._get(inst, "showOptions"), duration, postProcess);
4661 } else {
4662 inst.dpDiv[(showAnim === "slideDown" ? "slideUp" :
4663 (showAnim === "fadeIn" ? "fadeOut" : "hide"))]((showAnim ? duration : null), postProcess);
4664 }
4665
4666 if (!showAnim) {
4667 postProcess();
4668 }
4669 this._datepickerShowing = false;
4670
4671 onClose = this._get(inst, "onClose");
4672 if (onClose) {
4673 onClose.apply((inst.input ? inst.input[0] : null), [(inst.input ? inst.input.val() : ""), inst]);
4674 }
4675
4676 this._lastInput = null;
4677 if (this._inDialog) {
4678 this._dialogInput.css({ position: "absolute", left: "0", top: "-100px" });
4679 if ($.blockUI) {
4680 $.unblockUI();
4681 $("body").append(this.dpDiv);
4682 }
4683 }
4684 this._inDialog = false;
4685 }
4686 },
4687
4688 /* Tidy up after a dialog display. */
4689 _tidyDialog: function(inst) {
4690 inst.dpDiv.removeClass(this._dialogClass).unbind(".ui-datepicker-calendar");
4691 },
4692
4693 /* Close date picker if clicked elsewhere. */
4694 _checkExternalClick: function(event) {
4695 if (!$.datepicker._curInst) {
4696 return;
4697 }
4698
4699 var $target = $(event.target),
4700 inst = $.datepicker._getInst($target[0]);
4701
4702 if ( ( ( $target[0].id !== $.datepicker._mainDivId &&
4703 $target.parents("#" + $.datepicker._mainDivId).length === 0 &&
4704 !$target.hasClass($.datepicker.markerClassName) &&
4705 !$target.closest("." + $.datepicker._triggerClass).length &&
4706 $.datepicker._datepickerShowing && !($.datepicker._inDialog && $.blockUI) ) ) ||
4707 ( $target.hasClass($.datepicker.markerClassName) && $.datepicker._curInst !== inst ) ) {
4708 $.datepicker._hideDatepicker();
4709 }
4710 },
4711
4712 /* Adjust one of the date sub-fields. */
4713 _adjustDate: function(id, offset, period) {
4714 var target = $(id),
4715 inst = this._getInst(target[0]);
4716
4717 if (this._isDisabledDatepicker(target[0])) {
4718 return;
4719 }
4720 this._adjustInstDate(inst, offset +
4721 (period === "M" ? this._get(inst, "showCurrentAtPos") : 0), // undo positioning
4722 period);
4723 this._updateDatepicker(inst);
4724 },
4725
4726 /* Action for current link. */
4727 _gotoToday: function(id) {
4728 var date,
4729 target = $(id),
4730 inst = this._getInst(target[0]);
4731
4732 if (this._get(inst, "gotoCurrent") && inst.currentDay) {
4733 inst.selectedDay = inst.currentDay;
4734 inst.drawMonth = inst.selectedMonth = inst.currentMonth;
4735 inst.drawYear = inst.selectedYear = inst.currentYear;
4736 } else {
4737 date = new Date();
4738 inst.selectedDay = date.getDate();
4739 inst.drawMonth = inst.selectedMonth = date.getMonth();
4740 inst.drawYear = inst.selectedYear = date.getFullYear();
4741 }
4742 this._notifyChange(inst);
4743 this._adjustDate(target);
4744 },
4745
4746 /* Action for selecting a new month/year. */
4747 _selectMonthYear: function(id, select, period) {
4748 var target = $(id),
4749 inst = this._getInst(target[0]);
4750
4751 inst["selected" + (period === "M" ? "Month" : "Year")] =
4752 inst["draw" + (period === "M" ? "Month" : "Year")] =
4753 parseInt(select.options[select.selectedIndex].value,10);
4754
4755 this._notifyChange(inst);
4756 this._adjustDate(target);
4757 },
4758
4759 /* Action for selecting a day. */
4760 _selectDay: function(id, month, year, td) {
4761 var inst,
4762 target = $(id);
4763
4764 if ($(td).hasClass(this._unselectableClass) || this._isDisabledDatepicker(target[0])) {
4765 return;
4766 }
4767
4768 inst = this._getInst(target[0]);
4769 inst.selectedDay = inst.currentDay = $("a", td).html();
4770 inst.selectedMonth = inst.currentMonth = month;
4771 inst.selectedYear = inst.currentYear = year;
4772 this._selectDate(id, this._formatDate(inst,
4773 inst.currentDay, inst.currentMonth, inst.currentYear));
4774 },
4775
4776 /* Erase the input field and hide the date picker. */
4777 _clearDate: function(id) {
4778 var target = $(id);
4779 this._selectDate(target, "");
4780 },
4781
4782 /* Update the input field with the selected date. */
4783 _selectDate: function(id, dateStr) {
4784 var onSelect,
4785 target = $(id),
4786 inst = this._getInst(target[0]);
4787
4788 dateStr = (dateStr != null ? dateStr : this._formatDate(inst));
4789 if (inst.input) {
4790 inst.input.val(dateStr);
4791 }
4792 this._updateAlternate(inst);
4793
4794 onSelect = this._get(inst, "onSelect");
4795 if (onSelect) {
4796 onSelect.apply((inst.input ? inst.input[0] : null), [dateStr, inst]); // trigger custom callback
4797 } else if (inst.input) {
4798 inst.input.trigger("change"); // fire the change event
4799 }
4800
4801 if (inst.inline){
4802 this._updateDatepicker(inst);
4803 } else {
4804 this._hideDatepicker();
4805 this._lastInput = inst.input[0];
4806 if (typeof(inst.input[0]) !== "object") {
4807 inst.input.focus(); // restore focus
4808 }
4809 this._lastInput = null;
4810 }
4811 },
4812
4813 /* Update any alternate field to synchronise with the main field. */
4814 _updateAlternate: function(inst) {
4815 var altFormat, date, dateStr,
4816 altField = this._get(inst, "altField");
4817
4818 if (altField) { // update alternate field too
4819 altFormat = this._get(inst, "altFormat") || this._get(inst, "dateFormat");
4820 date = this._getDate(inst);
4821 dateStr = this.formatDate(altFormat, date, this._getFormatConfig(inst));
4822 $(altField).each(function() { $(this).val(dateStr); });
4823 }
4824 },
4825
4826 /* Set as beforeShowDay function to prevent selection of weekends.
4827 * @param date Date - the date to customise
4828 * @return [boolean, string] - is this date selectable?, what is its CSS class?
4829 */
4830 noWeekends: function(date) {
4831 var day = date.getDay();
4832 return [(day > 0 && day < 6), ""];
4833 },
4834
4835 /* Set as calculateWeek to determine the week of the year based on the ISO 8601 definition.
4836 * @param date Date - the date to get the week for
4837 * @return number - the number of the week within the year that contains this date
4838 */
4839 iso8601Week: function(date) {
4840 var time,
4841 checkDate = new Date(date.getTime());
4842
4843 // Find Thursday of this week starting on Monday
4844 checkDate.setDate(checkDate.getDate() + 4 - (checkDate.getDay() || 7));
4845
4846 time = checkDate.getTime();
4847 checkDate.setMonth(0); // Compare with Jan 1
4848 checkDate.setDate(1);
4849 return Math.floor(Math.round((time - checkDate) / 86400000) / 7) + 1;
4850 },
4851
4852 /* Parse a string value into a date object.
4853 * See formatDate below for the possible formats.
4854 *
4855 * @param format string - the expected format of the date
4856 * @param value string - the date in the above format
4857 * @param settings Object - attributes include:
4858 * shortYearCutoff number - the cutoff year for determining the century (optional)
4859 * dayNamesShort string[7] - abbreviated names of the days from Sunday (optional)
4860 * dayNames string[7] - names of the days from Sunday (optional)
4861 * monthNamesShort string[12] - abbreviated names of the months (optional)
4862 * monthNames string[12] - names of the months (optional)
4863 * @return Date - the extracted date value or null if value is blank
4864 */
4865 parseDate: function (format, value, settings) {
4866 if (format == null || value == null) {
4867 throw "Invalid arguments";
4868 }
4869
4870 value = (typeof value === "object" ? value.toString() : value + "");
4871 if (value === "") {
4872 return null;
4873 }
4874
4875 var iFormat, dim, extra,
4876 iValue = 0,
4877 shortYearCutoffTemp = (settings ? settings.shortYearCutoff : null) || this._defaults.shortYearCutoff,
4878 shortYearCutoff = (typeof shortYearCutoffTemp !== "string" ? shortYearCutoffTemp :
4879 new Date().getFullYear() % 100 + parseInt(shortYearCutoffTemp, 10)),
4880 dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort,
4881 dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames,
4882 monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort,
4883 monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames,
4884 year = -1,
4885 month = -1,
4886 day = -1,
4887 doy = -1,
4888 literal = false,
4889 date,
4890 // Check whether a format character is doubled
4891 lookAhead = function(match) {
4892 var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
4893 if (matches) {
4894 iFormat++;
4895 }
4896 return matches;
4897 },
4898 // Extract a number from the string value
4899 getNumber = function(match) {
4900 var isDoubled = lookAhead(match),
4901 size = (match === "@" ? 14 : (match === "!" ? 20 :
4902 (match === "y" && isDoubled ? 4 : (match === "o" ? 3 : 2)))),
4903 minSize = (match === "y" ? size : 1),
4904 digits = new RegExp("^\\d{" + minSize + "," + size + "}"),
4905 num = value.substring(iValue).match(digits);
4906 if (!num) {
4907 throw "Missing number at position " + iValue;
4908 }
4909 iValue += num[0].length;
4910 return parseInt(num[0], 10);
4911 },
4912 // Extract a name from the string value and convert to an index
4913 getName = function(match, shortNames, longNames) {
4914 var index = -1,
4915 names = $.map(lookAhead(match) ? longNames : shortNames, function (v, k) {
4916 return [ [k, v] ];
4917 }).sort(function (a, b) {
4918 return -(a[1].length - b[1].length);
4919 });
4920
4921 $.each(names, function (i, pair) {
4922 var name = pair[1];
4923 if (value.substr(iValue, name.length).toLowerCase() === name.toLowerCase()) {
4924 index = pair[0];
4925 iValue += name.length;
4926 return false;
4927 }
4928 });
4929 if (index !== -1) {
4930 return index + 1;
4931 } else {
4932 throw "Unknown name at position " + iValue;
4933 }
4934 },
4935 // Confirm that a literal character matches the string value
4936 checkLiteral = function() {
4937 if (value.charAt(iValue) !== format.charAt(iFormat)) {
4938 throw "Unexpected literal at position " + iValue;
4939 }
4940 iValue++;
4941 };
4942
4943 for (iFormat = 0; iFormat < format.length; iFormat++) {
4944 if (literal) {
4945 if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
4946 literal = false;
4947 } else {
4948 checkLiteral();
4949 }
4950 } else {
4951 switch (format.charAt(iFormat)) {
4952 case "d":
4953 day = getNumber("d");
4954 break;
4955 case "D":
4956 getName("D", dayNamesShort, dayNames);
4957 break;
4958 case "o":
4959 doy = getNumber("o");
4960 break;
4961 case "m":
4962 month = getNumber("m");
4963 break;
4964 case "M":
4965 month = getName("M", monthNamesShort, monthNames);
4966 break;
4967 case "y":
4968 year = getNumber("y");
4969 break;
4970 case "@":
4971 date = new Date(getNumber("@"));
4972 year = date.getFullYear();
4973 month = date.getMonth() + 1;
4974 day = date.getDate();
4975 break;
4976 case "!":
4977 date = new Date((getNumber("!") - this._ticksTo1970) / 10000);
4978 year = date.getFullYear();
4979 month = date.getMonth() + 1;
4980 day = date.getDate();
4981 break;
4982 case "'":
4983 if (lookAhead("'")){
4984 checkLiteral();
4985 } else {
4986 literal = true;
4987 }
4988 break;
4989 default:
4990 checkLiteral();
4991 }
4992 }
4993 }
4994
4995 if (iValue < value.length){
4996 extra = value.substr(iValue);
4997 if (!/^\s+/.test(extra)) {
4998 throw "Extra/unparsed characters found in date: " + extra;
4999 }
5000 }
5001
5002 if (year === -1) {
5003 year = new Date().getFullYear();
5004 } else if (year < 100) {
5005 year += new Date().getFullYear() - new Date().getFullYear() % 100 +
5006 (year <= shortYearCutoff ? 0 : -100);
5007 }
5008
5009 if (doy > -1) {
5010 month = 1;
5011 day = doy;
5012 do {
5013 dim = this._getDaysInMonth(year, month - 1);
5014 if (day <= dim) {
5015 break;
5016 }
5017 month++;
5018 day -= dim;
5019 } while (true);
5020 }
5021
5022 date = this._daylightSavingAdjust(new Date(year, month - 1, day));
5023 if (date.getFullYear() !== year || date.getMonth() + 1 !== month || date.getDate() !== day) {
5024 throw "Invalid date"; // E.g. 31/02/00
5025 }
5026 return date;
5027 },
5028
5029 /* Standard date formats. */
5030 ATOM: "yy-mm-dd", // RFC 3339 (ISO 8601)
5031 COOKIE: "D, dd M yy",
5032 ISO_8601: "yy-mm-dd",
5033 RFC_822: "D, d M y",
5034 RFC_850: "DD, dd-M-y",
5035 RFC_1036: "D, d M y",
5036 RFC_1123: "D, d M yy",
5037 RFC_2822: "D, d M yy",
5038 RSS: "D, d M y", // RFC 822
5039 TICKS: "!",
5040 TIMESTAMP: "@",
5041 W3C: "yy-mm-dd", // ISO 8601
5042
5043 _ticksTo1970: (((1970 - 1) * 365 + Math.floor(1970 / 4) - Math.floor(1970 / 100) +
5044 Math.floor(1970 / 400)) * 24 * 60 * 60 * 10000000),
5045
5046 /* Format a date object into a string value.
5047 * The format can be combinations of the following:
5048 * d - day of month (no leading zero)
5049 * dd - day of month (two digit)
5050 * o - day of year (no leading zeros)
5051 * oo - day of year (three digit)
5052 * D - day name short
5053 * DD - day name long
5054 * m - month of year (no leading zero)
5055 * mm - month of year (two digit)
5056 * M - month name short
5057 * MM - month name long
5058 * y - year (two digit)
5059 * yy - year (four digit)
5060 * @ - Unix timestamp (ms since 01/01/1970)
5061 * ! - Windows ticks (100ns since 01/01/0001)
5062 * "..." - literal text
5063 * '' - single quote
5064 *
5065 * @param format string - the desired format of the date
5066 * @param date Date - the date value to format
5067 * @param settings Object - attributes include:
5068 * dayNamesShort string[7] - abbreviated names of the days from Sunday (optional)
5069 * dayNames string[7] - names of the days from Sunday (optional)
5070 * monthNamesShort string[12] - abbreviated names of the months (optional)
5071 * monthNames string[12] - names of the months (optional)
5072 * @return string - the date in the above format
5073 */
5074 formatDate: function (format, date, settings) {
5075 if (!date) {
5076 return "";
5077 }
5078
5079 var iFormat,
5080 dayNamesShort = (settings ? settings.dayNamesShort : null) || this._defaults.dayNamesShort,
5081 dayNames = (settings ? settings.dayNames : null) || this._defaults.dayNames,
5082 monthNamesShort = (settings ? settings.monthNamesShort : null) || this._defaults.monthNamesShort,
5083 monthNames = (settings ? settings.monthNames : null) || this._defaults.monthNames,
5084 // Check whether a format character is doubled
5085 lookAhead = function(match) {
5086 var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
5087 if (matches) {
5088 iFormat++;
5089 }
5090 return matches;
5091 },
5092 // Format a number, with leading zero if necessary
5093 formatNumber = function(match, value, len) {
5094 var num = "" + value;
5095 if (lookAhead(match)) {
5096 while (num.length < len) {
5097 num = "0" + num;
5098 }
5099 }
5100 return num;
5101 },
5102 // Format a name, short or long as requested
5103 formatName = function(match, value, shortNames, longNames) {
5104 return (lookAhead(match) ? longNames[value] : shortNames[value]);
5105 },
5106 output = "",
5107 literal = false;
5108
5109 if (date) {
5110 for (iFormat = 0; iFormat < format.length; iFormat++) {
5111 if (literal) {
5112 if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
5113 literal = false;
5114 } else {
5115 output += format.charAt(iFormat);
5116 }
5117 } else {
5118 switch (format.charAt(iFormat)) {
5119 case "d":
5120 output += formatNumber("d", date.getDate(), 2);
5121 break;
5122 case "D":
5123 output += formatName("D", date.getDay(), dayNamesShort, dayNames);
5124 break;
5125 case "o":
5126 output += formatNumber("o",
5127 Math.round((new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime() - new Date(date.getFullYear(), 0, 0).getTime()) / 86400000), 3);
5128 break;
5129 case "m":
5130 output += formatNumber("m", date.getMonth() + 1, 2);
5131 break;
5132 case "M":
5133 output += formatName("M", date.getMonth(), monthNamesShort, monthNames);
5134 break;
5135 case "y":
5136 output += (lookAhead("y") ? date.getFullYear() :
5137 (date.getYear() % 100 < 10 ? "0" : "") + date.getYear() % 100);
5138 break;
5139 case "@":
5140 output += date.getTime();
5141 break;
5142 case "!":
5143 output += date.getTime() * 10000 + this._ticksTo1970;
5144 break;
5145 case "'":
5146 if (lookAhead("'")) {
5147 output += "'";
5148 } else {
5149 literal = true;
5150 }
5151 break;
5152 default:
5153 output += format.charAt(iFormat);
5154 }
5155 }
5156 }
5157 }
5158 return output;
5159 },
5160
5161 /* Extract all possible characters from the date format. */
5162 _possibleChars: function (format) {
5163 var iFormat,
5164 chars = "",
5165 literal = false,
5166 // Check whether a format character is doubled
5167 lookAhead = function(match) {
5168 var matches = (iFormat + 1 < format.length && format.charAt(iFormat + 1) === match);
5169 if (matches) {
5170 iFormat++;
5171 }
5172 return matches;
5173 };
5174
5175 for (iFormat = 0; iFormat < format.length; iFormat++) {
5176 if (literal) {
5177 if (format.charAt(iFormat) === "'" && !lookAhead("'")) {
5178 literal = false;
5179 } else {
5180 chars += format.charAt(iFormat);
5181 }
5182 } else {
5183 switch (format.charAt(iFormat)) {
5184 case "d": case "m": case "y": case "@":
5185 chars += "0123456789";
5186 break;
5187 case "D": case "M":
5188 return null; // Accept anything
5189 case "'":
5190 if (lookAhead("'")) {
5191 chars += "'";
5192 } else {
5193 literal = true;
5194 }
5195 break;
5196 default:
5197 chars += format.charAt(iFormat);
5198 }
5199 }
5200 }
5201 return chars;
5202 },
5203
5204 /* Get a setting value, defaulting if necessary. */
5205 _get: function(inst, name) {
5206 return inst.settings[name] !== undefined ?
5207 inst.settings[name] : this._defaults[name];
5208 },
5209
5210 /* Parse existing date and initialise date picker. */
5211 _setDateFromField: function(inst, noDefault) {
5212 if (inst.input.val() === inst.lastVal) {
5213 return;
5214 }
5215
5216 var dateFormat = this._get(inst, "dateFormat"),
5217 dates = inst.lastVal = inst.input ? inst.input.val() : null,
5218 defaultDate = this._getDefaultDate(inst),
5219 date = defaultDate,
5220 settings = this._getFormatConfig(inst);
5221
5222 try {
5223 date = this.parseDate(dateFormat, dates, settings) || defaultDate;
5224 } catch (event) {
5225 dates = (noDefault ? "" : dates);
5226 }
5227 inst.selectedDay = date.getDate();
5228 inst.drawMonth = inst.selectedMonth = date.getMonth();
5229 inst.drawYear = inst.selectedYear = date.getFullYear();
5230 inst.currentDay = (dates ? date.getDate() : 0);
5231 inst.currentMonth = (dates ? date.getMonth() : 0);
5232 inst.currentYear = (dates ? date.getFullYear() : 0);
5233 this._adjustInstDate(inst);
5234 },
5235
5236 /* Retrieve the default date shown on opening. */
5237 _getDefaultDate: function(inst) {
5238 return this._restrictMinMax(inst,
5239 this._determineDate(inst, this._get(inst, "defaultDate"), new Date()));
5240 },
5241
5242 /* A date may be specified as an exact value or a relative one. */
5243 _determineDate: function(inst, date, defaultDate) {
5244 var offsetNumeric = function(offset) {
5245 var date = new Date();
5246 date.setDate(date.getDate() + offset);
5247 return date;
5248 },
5249 offsetString = function(offset) {
5250 try {
5251 return $.datepicker.parseDate($.datepicker._get(inst, "dateFormat"),
5252 offset, $.datepicker._getFormatConfig(inst));
5253 }
5254 catch (e) {
5255 // Ignore
5256 }
5257
5258 var date = (offset.toLowerCase().match(/^c/) ?
5259 $.datepicker._getDate(inst) : null) || new Date(),
5260 year = date.getFullYear(),
5261 month = date.getMonth(),
5262 day = date.getDate(),
5263 pattern = /([+\-]?[0-9]+)\s*(d|D|w|W|m|M|y|Y)?/g,
5264 matches = pattern.exec(offset);
5265
5266 while (matches) {
5267 switch (matches[2] || "d") {
5268 case "d" : case "D" :
5269 day += parseInt(matches[1],10); break;
5270 case "w" : case "W" :
5271 day += parseInt(matches[1],10) * 7; break;
5272 case "m" : case "M" :
5273 month += parseInt(matches[1],10);
5274 day = Math.min(day, $.datepicker._getDaysInMonth(year, month));
5275 break;
5276 case "y": case "Y" :
5277 year += parseInt(matches[1],10);
5278 day = Math.min(day, $.datepicker._getDaysInMonth(year, month));
5279 break;
5280 }
5281 matches = pattern.exec(offset);
5282 }
5283 return new Date(year, month, day);
5284 },
5285 newDate = (date == null || date === "" ? defaultDate : (typeof date === "string" ? offsetString(date) :
5286 (typeof date === "number" ? (isNaN(date) ? defaultDate : offsetNumeric(date)) : new Date(date.getTime()))));
5287
5288 newDate = (newDate && newDate.toString() === "Invalid Date" ? defaultDate : newDate);
5289 if (newDate) {
5290 newDate.setHours(0);
5291 newDate.setMinutes(0);
5292 newDate.setSeconds(0);
5293 newDate.setMilliseconds(0);
5294 }
5295 return this._daylightSavingAdjust(newDate);
5296 },
5297
5298 /* Handle switch to/from daylight saving.
5299 * Hours may be non-zero on daylight saving cut-over:
5300 * > 12 when midnight changeover, but then cannot generate
5301 * midnight datetime, so jump to 1AM, otherwise reset.
5302 * @param date (Date) the date to check
5303 * @return (Date) the corrected date
5304 */
5305 _daylightSavingAdjust: function(date) {
5306 if (!date) {
5307 return null;
5308 }
5309 date.setHours(date.getHours() > 12 ? date.getHours() + 2 : 0);
5310 return date;
5311 },
5312
5313 /* Set the date(s) directly. */
5314 _setDate: function(inst, date, noChange) {
5315 var clear = !date,
5316 origMonth = inst.selectedMonth,
5317 origYear = inst.selectedYear,
5318 newDate = this._restrictMinMax(inst, this._determineDate(inst, date, new Date()));
5319
5320 inst.selectedDay = inst.currentDay = newDate.getDate();
5321 inst.drawMonth = inst.selectedMonth = inst.currentMonth = newDate.getMonth();
5322 inst.drawYear = inst.selectedYear = inst.currentYear = newDate.getFullYear();
5323 if ((origMonth !== inst.selectedMonth || origYear !== inst.selectedYear) && !noChange) {
5324 this._notifyChange(inst);
5325 }
5326 this._adjustInstDate(inst);
5327 if (inst.input) {
5328 inst.input.val(clear ? "" : this._formatDate(inst));
5329 }
5330 },
5331
5332 /* Retrieve the date(s) directly. */
5333 _getDate: function(inst) {
5334 var startDate = (!inst.currentYear || (inst.input && inst.input.val() === "") ? null :
5335 this._daylightSavingAdjust(new Date(
5336 inst.currentYear, inst.currentMonth, inst.currentDay)));
5337 return startDate;
5338 },
5339
5340 /* Attach the onxxx handlers. These are declared statically so
5341 * they work with static code transformers like Caja.
5342 */
5343 _attachHandlers: function(inst) {
5344 var stepMonths = this._get(inst, "stepMonths"),
5345 id = "#" + inst.id.replace( /\\\\/g, "\\" );
5346 inst.dpDiv.find("[data-handler]").map(function () {
5347 var handler = {
5348 prev: function () {
5349 $.datepicker._adjustDate(id, -stepMonths, "M");
5350 },
5351 next: function () {
5352 $.datepicker._adjustDate(id, +stepMonths, "M");
5353 },
5354 hide: function () {
5355 $.datepicker._hideDatepicker();
5356 },
5357 today: function () {
5358 $.datepicker._gotoToday(id);
5359 },
5360 selectDay: function () {
5361 $.datepicker._selectDay(id, +this.getAttribute("data-month"), +this.getAttribute("data-year"), this);
5362 return false;
5363 },
5364 selectMonth: function () {
5365 $.datepicker._selectMonthYear(id, this, "M");
5366 return false;
5367 },
5368 selectYear: function () {
5369 $.datepicker._selectMonthYear(id, this, "Y");
5370 return false;
5371 }
5372 };
5373 $(this).bind(this.getAttribute("data-event"), handler[this.getAttribute("data-handler")]);
5374 });
5375 },
5376
5377 /* Generate the HTML for the current state of the date picker. */
5378 _generateHTML: function(inst) {
5379 var maxDraw, prevText, prev, nextText, next, currentText, gotoDate,
5380 controls, buttonPanel, firstDay, showWeek, dayNames, dayNamesMin,
5381 monthNames, monthNamesShort, beforeShowDay, showOtherMonths,
5382 selectOtherMonths, defaultDate, html, dow, row, group, col, selectedDate,
5383 cornerClass, calender, thead, day, daysInMonth, leadDays, curRows, numRows,
5384 printDate, dRow, tbody, daySettings, otherMonth, unselectable,
5385 tempDate = new Date(),
5386 today = this._daylightSavingAdjust(
5387 new Date(tempDate.getFullYear(), tempDate.getMonth(), tempDate.getDate())), // clear time
5388 isRTL = this._get(inst, "isRTL"),
5389 showButtonPanel = this._get(inst, "showButtonPanel"),
5390 hideIfNoPrevNext = this._get(inst, "hideIfNoPrevNext"),
5391 navigationAsDateFormat = this._get(inst, "navigationAsDateFormat"),
5392 numMonths = this._getNumberOfMonths(inst),
5393 showCurrentAtPos = this._get(inst, "showCurrentAtPos"),
5394 stepMonths = this._get(inst, "stepMonths"),
5395 isMultiMonth = (numMonths[0] !== 1 || numMonths[1] !== 1),
5396 currentDate = this._daylightSavingAdjust((!inst.currentDay ? new Date(9999, 9, 9) :
5397 new Date(inst.currentYear, inst.currentMonth, inst.currentDay))),
5398 minDate = this._getMinMaxDate(inst, "min"),
5399 maxDate = this._getMinMaxDate(inst, "max"),
5400 drawMonth = inst.drawMonth - showCurrentAtPos,
5401 drawYear = inst.drawYear;
5402
5403 if (drawMonth < 0) {
5404 drawMonth += 12;
5405 drawYear--;
5406 }
5407 if (maxDate) {
5408 maxDraw = this._daylightSavingAdjust(new Date(maxDate.getFullYear(),
5409 maxDate.getMonth() - (numMonths[0] * numMonths[1]) + 1, maxDate.getDate()));
5410 maxDraw = (minDate && maxDraw < minDate ? minDate : maxDraw);
5411 while (this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1)) > maxDraw) {
5412 drawMonth--;
5413 if (drawMonth < 0) {
5414 drawMonth = 11;
5415 drawYear--;
5416 }
5417 }
5418 }
5419 inst.drawMonth = drawMonth;
5420 inst.drawYear = drawYear;
5421
5422 prevText = this._get(inst, "prevText");
5423 prevText = (!navigationAsDateFormat ? prevText : this.formatDate(prevText,
5424 this._daylightSavingAdjust(new Date(drawYear, drawMonth - stepMonths, 1)),
5425 this._getFormatConfig(inst)));
5426
5427 prev = (this._canAdjustMonth(inst, -1, drawYear, drawMonth) ?
5428 "<a class='ui-datepicker-prev ui-corner-all' data-handler='prev' data-event='click'" +
5429 " title='" + prevText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "e" : "w") + "'>" + prevText + "</span></a>" :
5430 (hideIfNoPrevNext ? "" : "<a class='ui-datepicker-prev ui-corner-all ui-state-disabled' title='"+ prevText +"'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "e" : "w") + "'>" + prevText + "</span></a>"));
5431
5432 nextText = this._get(inst, "nextText");
5433 nextText = (!navigationAsDateFormat ? nextText : this.formatDate(nextText,
5434 this._daylightSavingAdjust(new Date(drawYear, drawMonth + stepMonths, 1)),
5435 this._getFormatConfig(inst)));
5436
5437 next = (this._canAdjustMonth(inst, +1, drawYear, drawMonth) ?
5438 "<a class='ui-datepicker-next ui-corner-all' data-handler='next' data-event='click'" +
5439 " title='" + nextText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "w" : "e") + "'>" + nextText + "</span></a>" :
5440 (hideIfNoPrevNext ? "" : "<a class='ui-datepicker-next ui-corner-all ui-state-disabled' title='"+ nextText + "'><span class='ui-icon ui-icon-circle-triangle-" + ( isRTL ? "w" : "e") + "'>" + nextText + "</span></a>"));
5441
5442 currentText = this._get(inst, "currentText");
5443 gotoDate = (this._get(inst, "gotoCurrent") && inst.currentDay ? currentDate : today);
5444 currentText = (!navigationAsDateFormat ? currentText :
5445 this.formatDate(currentText, gotoDate, this._getFormatConfig(inst)));
5446
5447 controls = (!inst.inline ? "<button type='button' class='ui-datepicker-close ui-state-default ui-priority-primary ui-corner-all' data-handler='hide' data-event='click'>" +
5448 this._get(inst, "closeText") + "</button>" : "");
5449
5450 buttonPanel = (showButtonPanel) ? "<div class='ui-datepicker-buttonpane ui-widget-content'>" + (isRTL ? controls : "") +
5451 (this._isInRange(inst, gotoDate) ? "<button type='button' class='ui-datepicker-current ui-state-default ui-priority-secondary ui-corner-all' data-handler='today' data-event='click'" +
5452 ">" + currentText + "</button>" : "") + (isRTL ? "" : controls) + "</div>" : "";
5453
5454 firstDay = parseInt(this._get(inst, "firstDay"),10);
5455 firstDay = (isNaN(firstDay) ? 0 : firstDay);
5456
5457 showWeek = this._get(inst, "showWeek");
5458 dayNames = this._get(inst, "dayNames");
5459 dayNamesMin = this._get(inst, "dayNamesMin");
5460 monthNames = this._get(inst, "monthNames");
5461 monthNamesShort = this._get(inst, "monthNamesShort");
5462 beforeShowDay = this._get(inst, "beforeShowDay");
5463 showOtherMonths = this._get(inst, "showOtherMonths");
5464 selectOtherMonths = this._get(inst, "selectOtherMonths");
5465 defaultDate = this._getDefaultDate(inst);
5466 html = "";
5467 dow;
5468 for (row = 0; row < numMonths[0]; row++) {
5469 group = "";
5470 this.maxRows = 4;
5471 for (col = 0; col < numMonths[1]; col++) {
5472 selectedDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, inst.selectedDay));
5473 cornerClass = " ui-corner-all";
5474 calender = "";
5475 if (isMultiMonth) {
5476 calender += "<div class='ui-datepicker-group";
5477 if (numMonths[1] > 1) {
5478 switch (col) {
5479 case 0: calender += " ui-datepicker-group-first";
5480 cornerClass = " ui-corner-" + (isRTL ? "right" : "left"); break;
5481 case numMonths[1]-1: calender += " ui-datepicker-group-last";
5482 cornerClass = " ui-corner-" + (isRTL ? "left" : "right"); break;
5483 default: calender += " ui-datepicker-group-middle"; cornerClass = ""; break;
5484 }
5485 }
5486 calender += "'>";
5487 }
5488 calender += "<div class='ui-datepicker-header ui-widget-header ui-helper-clearfix" + cornerClass + "'>" +
5489 (/all|left/.test(cornerClass) && row === 0 ? (isRTL ? next : prev) : "") +
5490 (/all|right/.test(cornerClass) && row === 0 ? (isRTL ? prev : next) : "") +
5491 this._generateMonthYearHeader(inst, drawMonth, drawYear, minDate, maxDate,
5492 row > 0 || col > 0, monthNames, monthNamesShort) + // draw month headers
5493 "</div><table class='ui-datepicker-calendar'><thead>" +
5494 "<tr>";
5495 thead = (showWeek ? "<th class='ui-datepicker-week-col'>" + this._get(inst, "weekHeader") + "</th>" : "");
5496 for (dow = 0; dow < 7; dow++) { // days of the week
5497 day = (dow + firstDay) % 7;
5498 thead += "<th scope='col'" + ((dow + firstDay + 6) % 7 >= 5 ? " class='ui-datepicker-week-end'" : "") + ">" +
5499 "<span title='" + dayNames[day] + "'>" + dayNamesMin[day] + "</span></th>";
5500 }
5501 calender += thead + "</tr></thead><tbody>";
5502 daysInMonth = this._getDaysInMonth(drawYear, drawMonth);
5503 if (drawYear === inst.selectedYear && drawMonth === inst.selectedMonth) {
5504 inst.selectedDay = Math.min(inst.selectedDay, daysInMonth);
5505 }
5506 leadDays = (this._getFirstDayOfMonth(drawYear, drawMonth) - firstDay + 7) % 7;
5507 curRows = Math.ceil((leadDays + daysInMonth) / 7); // calculate the number of rows to generate
5508 numRows = (isMultiMonth ? this.maxRows > curRows ? this.maxRows : curRows : curRows); //If multiple months, use the higher number of rows (see #7043)
5509 this.maxRows = numRows;
5510 printDate = this._daylightSavingAdjust(new Date(drawYear, drawMonth, 1 - leadDays));
5511 for (dRow = 0; dRow < numRows; dRow++) { // create date picker rows
5512 calender += "<tr>";
5513 tbody = (!showWeek ? "" : "<td class='ui-datepicker-week-col'>" +
5514 this._get(inst, "calculateWeek")(printDate) + "</td>");
5515 for (dow = 0; dow < 7; dow++) { // create date picker days
5516 daySettings = (beforeShowDay ?
5517 beforeShowDay.apply((inst.input ? inst.input[0] : null), [printDate]) : [true, ""]);
5518 otherMonth = (printDate.getMonth() !== drawMonth);
5519 unselectable = (otherMonth && !selectOtherMonths) || !daySettings[0] ||
5520 (minDate && printDate < minDate) || (maxDate && printDate > maxDate);
5521 tbody += "<td class='" +
5522 ((dow + firstDay + 6) % 7 >= 5 ? " ui-datepicker-week-end" : "") + // highlight weekends
5523 (otherMonth ? " ui-datepicker-other-month" : "") + // highlight days from other months
5524 ((printDate.getTime() === selectedDate.getTime() && drawMonth === inst.selectedMonth && inst._keyEvent) || // user pressed key
5525 (defaultDate.getTime() === printDate.getTime() && defaultDate.getTime() === selectedDate.getTime()) ?
5526 // or defaultDate is current printedDate and defaultDate is selectedDate
5527 " " + this._dayOverClass : "") + // highlight selected day
5528 (unselectable ? " " + this._unselectableClass + " ui-state-disabled": "") + // highlight unselectable days
5529 (otherMonth && !showOtherMonths ? "" : " " + daySettings[1] + // highlight custom dates
5530 (printDate.getTime() === currentDate.getTime() ? " " + this._currentClass : "") + // highlight selected day
5531 (printDate.getTime() === today.getTime() ? " ui-datepicker-today" : "")) + "'" + // highlight today (if different)
5532 ((!otherMonth || showOtherMonths) && daySettings[2] ? " title='" + daySettings[2].replace(/'/g, "'") + "'" : "") + // cell title
5533 (unselectable ? "" : " data-handler='selectDay' data-event='click' data-month='" + printDate.getMonth() + "' data-year='" + printDate.getFullYear() + "'") + ">" + // actions
5534 (otherMonth && !showOtherMonths ? " " : // display for other months
5535 (unselectable ? "<span class='ui-state-default'>" + printDate.getDate() + "</span>" : "<a class='ui-state-default" +
5536 (printDate.getTime() === today.getTime() ? " ui-state-highlight" : "") +
5537 (printDate.getTime() === currentDate.getTime() ? " ui-state-active" : "") + // highlight selected day
5538 (otherMonth ? " ui-priority-secondary" : "") + // distinguish dates from other months
5539 "' href='#'>" + printDate.getDate() + "</a>")) + "</td>"; // display selectable date
5540 printDate.setDate(printDate.getDate() + 1);
5541 printDate = this._daylightSavingAdjust(printDate);
5542 }
5543 calender += tbody + "</tr>";
5544 }
5545 drawMonth++;
5546 if (drawMonth > 11) {
5547 drawMonth = 0;
5548 drawYear++;
5549 }
5550 calender += "</tbody></table>" + (isMultiMonth ? "</div>" +
5551 ((numMonths[0] > 0 && col === numMonths[1]-1) ? "<div class='ui-datepicker-row-break'></div>" : "") : "");
5552 group += calender;
5553 }
5554 html += group;
5555 }
5556 html += buttonPanel;
5557 inst._keyEvent = false;
5558 return html;
5559 },
5560
5561 /* Generate the month and year header. */
5562 _generateMonthYearHeader: function(inst, drawMonth, drawYear, minDate, maxDate,
5563 secondary, monthNames, monthNamesShort) {
5564
5565 var inMinYear, inMaxYear, month, years, thisYear, determineYear, year, endYear,
5566 changeMonth = this._get(inst, "changeMonth"),
5567 changeYear = this._get(inst, "changeYear"),
5568 showMonthAfterYear = this._get(inst, "showMonthAfterYear"),
5569 html = "<div class='ui-datepicker-title'>",
5570 monthHtml = "";
5571
5572 // month selection
5573 if (secondary || !changeMonth) {
5574 monthHtml += "<span class='ui-datepicker-month'>" + monthNames[drawMonth] + "</span>";
5575 } else {
5576 inMinYear = (minDate && minDate.getFullYear() === drawYear);
5577 inMaxYear = (maxDate && maxDate.getFullYear() === drawYear);
5578 monthHtml += "<select class='ui-datepicker-month' data-handler='selectMonth' data-event='change'>";
5579 for ( month = 0; month < 12; month++) {
5580 if ((!inMinYear || month >= minDate.getMonth()) && (!inMaxYear || month <= maxDate.getMonth())) {
5581 monthHtml += "<option value='" + month + "'" +
5582 (month === drawMonth ? " selected='selected'" : "") +
5583 ">" + monthNamesShort[month] + "</option>";
5584 }
5585 }
5586 monthHtml += "</select>";
5587 }
5588
5589 if (!showMonthAfterYear) {
5590 html += monthHtml + (secondary || !(changeMonth && changeYear) ? " " : "");
5591 }
5592
5593 // year selection
5594 if ( !inst.yearshtml ) {
5595 inst.yearshtml = "";
5596 if (secondary || !changeYear) {
5597 html += "<span class='ui-datepicker-year'>" + drawYear + "</span>";
5598 } else {
5599 // determine range of years to display
5600 years = this._get(inst, "yearRange").split(":");
5601 thisYear = new Date().getFullYear();
5602 determineYear = function(value) {
5603 var year = (value.match(/c[+\-].*/) ? drawYear + parseInt(value.substring(1), 10) :
5604 (value.match(/[+\-].*/) ? thisYear + parseInt(value, 10) :
5605 parseInt(value, 10)));
5606 return (isNaN(year) ? thisYear : year);
5607 };
5608 year = determineYear(years[0]);
5609 endYear = Math.max(year, determineYear(years[1] || ""));
5610 year = (minDate ? Math.max(year, minDate.getFullYear()) : year);
5611 endYear = (maxDate ? Math.min(endYear, maxDate.getFullYear()) : endYear);
5612 inst.yearshtml += "<select class='ui-datepicker-year' data-handler='selectYear' data-event='change'>";
5613 for (; year <= endYear; year++) {
5614 inst.yearshtml += "<option value='" + year + "'" +
5615 (year === drawYear ? " selected='selected'" : "") +
5616 ">" + year + "</option>";
5617 }
5618 inst.yearshtml += "</select>";
5619
5620 html += inst.yearshtml;
5621 inst.yearshtml = null;
5622 }
5623 }
5624
5625 html += this._get(inst, "yearSuffix");
5626 if (showMonthAfterYear) {
5627 html += (secondary || !(changeMonth && changeYear) ? " " : "") + monthHtml;
5628 }
5629 html += "</div>"; // Close datepicker_header
5630 return html;
5631 },
5632
5633 /* Adjust one of the date sub-fields. */
5634 _adjustInstDate: function(inst, offset, period) {
5635 var year = inst.drawYear + (period === "Y" ? offset : 0),
5636 month = inst.drawMonth + (period === "M" ? offset : 0),
5637 day = Math.min(inst.selectedDay, this._getDaysInMonth(year, month)) + (period === "D" ? offset : 0),
5638 date = this._restrictMinMax(inst, this._daylightSavingAdjust(new Date(year, month, day)));
5639
5640 inst.selectedDay = date.getDate();
5641 inst.drawMonth = inst.selectedMonth = date.getMonth();
5642 inst.drawYear = inst.selectedYear = date.getFullYear();
5643 if (period === "M" || period === "Y") {
5644 this._notifyChange(inst);
5645 }
5646 },
5647
5648 /* Ensure a date is within any min/max bounds. */
5649 _restrictMinMax: function(inst, date) {
5650 var minDate = this._getMinMaxDate(inst, "min"),
5651 maxDate = this._getMinMaxDate(inst, "max"),
5652 newDate = (minDate && date < minDate ? minDate : date);
5653 return (maxDate && newDate > maxDate ? maxDate : newDate);
5654 },
5655
5656 /* Notify change of month/year. */
5657 _notifyChange: function(inst) {
5658 var onChange = this._get(inst, "onChangeMonthYear");
5659 if (onChange) {
5660 onChange.apply((inst.input ? inst.input[0] : null),
5661 [inst.selectedYear, inst.selectedMonth + 1, inst]);
5662 }
5663 },
5664
5665 /* Determine the number of months to show. */
5666 _getNumberOfMonths: function(inst) {
5667 var numMonths = this._get(inst, "numberOfMonths");
5668 return (numMonths == null ? [1, 1] : (typeof numMonths === "number" ? [1, numMonths] : numMonths));
5669 },
5670
5671 /* Determine the current maximum date - ensure no time components are set. */
5672 _getMinMaxDate: function(inst, minMax) {
5673 return this._determineDate(inst, this._get(inst, minMax + "Date"), null);
5674 },
5675
5676 /* Find the number of days in a given month. */
5677 _getDaysInMonth: function(year, month) {
5678 return 32 - this._daylightSavingAdjust(new Date(year, month, 32)).getDate();
5679 },
5680
5681 /* Find the day of the week of the first of a month. */
5682 _getFirstDayOfMonth: function(year, month) {
5683 return new Date(year, month, 1).getDay();
5684 },
5685
5686 /* Determines if we should allow a "next/prev" month display change. */
5687 _canAdjustMonth: function(inst, offset, curYear, curMonth) {
5688 var numMonths = this._getNumberOfMonths(inst),
5689 date = this._daylightSavingAdjust(new Date(curYear,
5690 curMonth + (offset < 0 ? offset : numMonths[0] * numMonths[1]), 1));
5691
5692 if (offset < 0) {
5693 date.setDate(this._getDaysInMonth(date.getFullYear(), date.getMonth()));
5694 }
5695 return this._isInRange(inst, date);
5696 },
5697
5698 /* Is the given date in the accepted range? */
5699 _isInRange: function(inst, date) {
5700 var yearSplit, currentYear,
5701 minDate = this._getMinMaxDate(inst, "min"),
5702 maxDate = this._getMinMaxDate(inst, "max"),
5703 minYear = null,
5704 maxYear = null,
5705 years = this._get(inst, "yearRange");
5706 if (years){
5707 yearSplit = years.split(":");
5708 currentYear = new Date().getFullYear();
5709 minYear = parseInt(yearSplit[0], 10);
5710 maxYear = parseInt(yearSplit[1], 10);
5711 if ( yearSplit[0].match(/[+\-].*/) ) {
5712 minYear += currentYear;
5713 }
5714 if ( yearSplit[1].match(/[+\-].*/) ) {
5715 maxYear += currentYear;
5716 }
5717 }
5718
5719 return ((!minDate || date.getTime() >= minDate.getTime()) &&
5720 (!maxDate || date.getTime() <= maxDate.getTime()) &&
5721 (!minYear || date.getFullYear() >= minYear) &&
5722 (!maxYear || date.getFullYear() <= maxYear));
5723 },
5724
5725 /* Provide the configuration settings for formatting/parsing. */
5726 _getFormatConfig: function(inst) {
5727 var shortYearCutoff = this._get(inst, "shortYearCutoff");
5728 shortYearCutoff = (typeof shortYearCutoff !== "string" ? shortYearCutoff :
5729 new Date().getFullYear() % 100 + parseInt(shortYearCutoff, 10));
5730 return {shortYearCutoff: shortYearCutoff,
5731 dayNamesShort: this._get(inst, "dayNamesShort"), dayNames: this._get(inst, "dayNames"),
5732 monthNamesShort: this._get(inst, "monthNamesShort"), monthNames: this._get(inst, "monthNames")};
5733 },
5734
5735 /* Format the given date for display. */
5736 _formatDate: function(inst, day, month, year) {
5737 if (!day) {
5738 inst.currentDay = inst.selectedDay;
5739 inst.currentMonth = inst.selectedMonth;
5740 inst.currentYear = inst.selectedYear;
5741 }
5742 var date = (day ? (typeof day === "object" ? day :
5743 this._daylightSavingAdjust(new Date(year, month, day))) :
5744 this._daylightSavingAdjust(new Date(inst.currentYear, inst.currentMonth, inst.currentDay)));
5745 return this.formatDate(this._get(inst, "dateFormat"), date, this._getFormatConfig(inst));
5746 }
5747 });
5748
5749 /*
5750 * Bind hover events for datepicker elements.
5751 * Done via delegate so the binding only occurs once in the lifetime of the parent div.
5752 * Global datepicker_instActive, set by _updateDatepicker allows the handlers to find their way back to the active picker.
5753 */
5754 function datepicker_bindHover(dpDiv) {
5755 var selector = "button, .ui-datepicker-prev, .ui-datepicker-next, .ui-datepicker-calendar td a";
5756 return dpDiv.delegate(selector, "mouseout", function() {
5757 $(this).removeClass("ui-state-hover");
5758 if (this.className.indexOf("ui-datepicker-prev") !== -1) {
5759 $(this).removeClass("ui-datepicker-prev-hover");
5760 }
5761 if (this.className.indexOf("ui-datepicker-next") !== -1) {
5762 $(this).removeClass("ui-datepicker-next-hover");
5763 }
5764 })
5765 .delegate( selector, "mouseover", datepicker_handleMouseover );
5766 }
5767
5768 function datepicker_handleMouseover() {
5769 if (!$.datepicker._isDisabledDatepicker( datepicker_instActive.inline? datepicker_instActive.dpDiv.parent()[0] : datepicker_instActive.input[0])) {
5770 $(this).parents(".ui-datepicker-calendar").find("a").removeClass("ui-state-hover");
5771 $(this).addClass("ui-state-hover");
5772 if (this.className.indexOf("ui-datepicker-prev") !== -1) {
5773 $(this).addClass("ui-datepicker-prev-hover");
5774 }
5775 if (this.className.indexOf("ui-datepicker-next") !== -1) {
5776 $(this).addClass("ui-datepicker-next-hover");
5777 }
5778 }
5779 }
5780
5781 /* jQuery extend now ignores nulls! */
5782 function datepicker_extendRemove(target, props) {
5783 $.extend(target, props);
5784 for (var name in props) {
5785 if (props[name] == null) {
5786 target[name] = props[name];
5787 }
5788 }
5789 return target;
5790 }
5791
5792 /* Invoke the datepicker functionality.
5793 @param options string - a command, optionally followed by additional parameters or
5794 Object - settings for attaching new datepicker functionality
5795 @return jQuery object */
5796 $.fn.datepicker = function(options){
5797
5798 /* Verify an empty collection wasn't passed - Fixes #6976 */
5799 if ( !this.length ) {
5800 return this;
5801 }
5802
5803 /* Initialise the date picker. */
5804 if (!$.datepicker.initialized) {
5805 $(document).mousedown($.datepicker._checkExternalClick);
5806 $.datepicker.initialized = true;
5807 }
5808
5809 /* Append datepicker main container to body if not exist. */
5810 if ($("#"+$.datepicker._mainDivId).length === 0) {
5811 $("body").append($.datepicker.dpDiv);
5812 }
5813
5814 var otherArgs = Array.prototype.slice.call(arguments, 1);
5815 if (typeof options === "string" && (options === "isDisabled" || options === "getDate" || options === "widget")) {
5816 return $.datepicker["_" + options + "Datepicker"].
5817 apply($.datepicker, [this[0]].concat(otherArgs));
5818 }
5819 if (options === "option" && arguments.length === 2 && typeof arguments[1] === "string") {
5820 return $.datepicker["_" + options + "Datepicker"].
5821 apply($.datepicker, [this[0]].concat(otherArgs));
5822 }
5823 return this.each(function() {
5824 typeof options === "string" ?
5825 $.datepicker["_" + options + "Datepicker"].
5826 apply($.datepicker, [this].concat(otherArgs)) :
5827 $.datepicker._attachDatepicker(this, options);
5828 });
5829 };
5830
5831 $.datepicker = new Datepicker(); // singleton instance
5832 $.datepicker.initialized = false;
5833 $.datepicker.uuid = new Date().getTime();
5834 $.datepicker.version = "1.11.4";
5835
5836 var datepicker = $.datepicker;
5837
5838
5839 /*!
5840 * jQuery UI Draggable 1.11.4
5841 * http://jqueryui.com
5842 *
5843 * Copyright jQuery Foundation and other contributors
5844 * Released under the MIT license.
5845 * http://jquery.org/license
5846 *
5847 * http://api.jqueryui.com/draggable/
5848 */
5849
5850
5851 $.widget("ui.draggable", $.ui.mouse, {
5852 version: "1.11.4",
5853 widgetEventPrefix: "drag",
5854 options: {
5855 addClasses: true,
5856 appendTo: "parent",
5857 axis: false,
5858 connectToSortable: false,
5859 containment: false,
5860 cursor: "auto",
5861 cursorAt: false,
5862 grid: false,
5863 handle: false,
5864 helper: "original",
5865 iframeFix: false,
5866 opacity: false,
5867 refreshPositions: false,
5868 revert: false,
5869 revertDuration: 500,
5870 scope: "default",
5871 scroll: true,
5872 scrollSensitivity: 20,
5873 scrollSpeed: 20,
5874 snap: false,
5875 snapMode: "both",
5876 snapTolerance: 20,
5877 stack: false,
5878 zIndex: false,
5879
5880 // callbacks
5881 drag: null,
5882 start: null,
5883 stop: null
5884 },
5885 _create: function() {
5886
5887 if ( this.options.helper === "original" ) {
5888 this._setPositionRelative();
5889 }
5890 if (this.options.addClasses){
5891 this.element.addClass("ui-draggable");
5892 }
5893 if (this.options.disabled){
5894 this.element.addClass("ui-draggable-disabled");
5895 }
5896 this._setHandleClassName();
5897
5898 this._mouseInit();
5899 },
5900
5901 _setOption: function( key, value ) {
5902 this._super( key, value );
5903 if ( key === "handle" ) {
5904 this._removeHandleClassName();
5905 this._setHandleClassName();
5906 }
5907 },
5908
5909 _destroy: function() {
5910 if ( ( this.helper || this.element ).is( ".ui-draggable-dragging" ) ) {
5911 this.destroyOnClear = true;
5912 return;
5913 }
5914 this.element.removeClass( "ui-draggable ui-draggable-dragging ui-draggable-disabled" );
5915 this._removeHandleClassName();
5916 this._mouseDestroy();
5917 },
5918
5919 _mouseCapture: function(event) {
5920 var o = this.options;
5921
5922 this._blurActiveElement( event );
5923
5924 // among others, prevent a drag on a resizable-handle
5925 if (this.helper || o.disabled || $(event.target).closest(".ui-resizable-handle").length > 0) {
5926 return false;
5927 }
5928
5929 //Quit if we're not on a valid handle
5930 this.handle = this._getHandle(event);
5931 if (!this.handle) {
5932 return false;
5933 }
5934
5935 this._blockFrames( o.iframeFix === true ? "iframe" : o.iframeFix );
5936
5937 return true;
5938
5939 },
5940
5941 _blockFrames: function( selector ) {
5942 this.iframeBlocks = this.document.find( selector ).map(function() {
5943 var iframe = $( this );
5944
5945 return $( "<div>" )
5946 .css( "position", "absolute" )
5947 .appendTo( iframe.parent() )
5948 .outerWidth( iframe.outerWidth() )
5949 .outerHeight( iframe.outerHeight() )
5950 .offset( iframe.offset() )[ 0 ];
5951 });
5952 },
5953
5954 _unblockFrames: function() {
5955 if ( this.iframeBlocks ) {
5956 this.iframeBlocks.remove();
5957 delete this.iframeBlocks;
5958 }
5959 },
5960
5961 _blurActiveElement: function( event ) {
5962 var document = this.document[ 0 ];
5963
5964 // Only need to blur if the event occurred on the draggable itself, see #10527
5965 if ( !this.handleElement.is( event.target ) ) {
5966 return;
5967 }
5968
5969 // support: IE9
5970 // IE9 throws an "Unspecified error" accessing document.activeElement from an <iframe>
5971 try {
5972
5973 // Support: IE9, IE10
5974 // If the <body> is blurred, IE will switch windows, see #9520
5975 if ( document.activeElement && document.activeElement.nodeName.toLowerCase() !== "body" ) {
5976
5977 // Blur any element that currently has focus, see #4261
5978 $( document.activeElement ).blur();
5979 }
5980 } catch ( error ) {}
5981 },
5982
5983 _mouseStart: function(event) {
5984
5985 var o = this.options;
5986
5987 //Create and append the visible helper
5988 this.helper = this._createHelper(event);
5989
5990 this.helper.addClass("ui-draggable-dragging");
5991
5992 //Cache the helper size
5993 this._cacheHelperProportions();
5994
5995 //If ddmanager is used for droppables, set the global draggable
5996 if ($.ui.ddmanager) {
5997 $.ui.ddmanager.current = this;
5998 }
5999
6000 /*
6001 * - Position generation -
6002 * This block generates everything position related - it's the core of draggables.
6003 */
6004
6005 //Cache the margins of the original element
6006 this._cacheMargins();
6007
6008 //Store the helper's css position
6009 this.cssPosition = this.helper.css( "position" );
6010 this.scrollParent = this.helper.scrollParent( true );
6011 this.offsetParent = this.helper.offsetParent();
6012 this.hasFixedAncestor = this.helper.parents().filter(function() {
6013 return $( this ).css( "position" ) === "fixed";
6014 }).length > 0;
6015
6016 //The element's absolute position on the page minus margins
6017 this.positionAbs = this.element.offset();
6018 this._refreshOffsets( event );
6019
6020 //Generate the original position
6021 this.originalPosition = this.position = this._generatePosition( event, false );
6022 this.originalPageX = event.pageX;
6023 this.originalPageY = event.pageY;
6024
6025 //Adjust the mouse offset relative to the helper if "cursorAt" is supplied
6026 (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
6027
6028 //Set a containment if given in the options
6029 this._setContainment();
6030
6031 //Trigger event + callbacks
6032 if (this._trigger("start", event) === false) {
6033 this._clear();
6034 return false;
6035 }
6036
6037 //Recache the helper size
6038 this._cacheHelperProportions();
6039
6040 //Prepare the droppable offsets
6041 if ($.ui.ddmanager && !o.dropBehaviour) {
6042 $.ui.ddmanager.prepareOffsets(this, event);
6043 }
6044
6045 // Reset helper's right/bottom css if they're set and set explicit width/height instead
6046 // as this prevents resizing of elements with right/bottom set (see #7772)
6047 this._normalizeRightBottom();
6048
6049 this._mouseDrag(event, true); //Execute the drag once - this causes the helper not to be visible before getting its correct position
6050
6051 //If the ddmanager is used for droppables, inform the manager that dragging has started (see #5003)
6052 if ( $.ui.ddmanager ) {
6053 $.ui.ddmanager.dragStart(this, event);
6054 }
6055
6056 return true;
6057 },
6058
6059 _refreshOffsets: function( event ) {
6060 this.offset = {
6061 top: this.positionAbs.top - this.margins.top,
6062 left: this.positionAbs.left - this.margins.left,
6063 scroll: false,
6064 parent: this._getParentOffset(),
6065 relative: this._getRelativeOffset()
6066 };
6067
6068 this.offset.click = {
6069 left: event.pageX - this.offset.left,
6070 top: event.pageY - this.offset.top
6071 };
6072 },
6073
6074 _mouseDrag: function(event, noPropagation) {
6075 // reset any necessary cached properties (see #5009)
6076 if ( this.hasFixedAncestor ) {
6077 this.offset.parent = this._getParentOffset();
6078 }
6079
6080 //Compute the helpers position
6081 this.position = this._generatePosition( event, true );
6082 this.positionAbs = this._convertPositionTo("absolute");
6083
6084 //Call plugins and callbacks and use the resulting position if something is returned
6085 if (!noPropagation) {
6086 var ui = this._uiHash();
6087 if (this._trigger("drag", event, ui) === false) {
6088 this._mouseUp({});
6089 return false;
6090 }
6091 this.position = ui.position;
6092 }
6093
6094 this.helper[ 0 ].style.left = this.position.left + "px";
6095 this.helper[ 0 ].style.top = this.position.top + "px";
6096
6097 if ($.ui.ddmanager) {
6098 $.ui.ddmanager.drag(this, event);
6099 }
6100
6101 return false;
6102 },
6103
6104 _mouseStop: function(event) {
6105
6106 //If we are using droppables, inform the manager about the drop
6107 var that = this,
6108 dropped = false;
6109 if ($.ui.ddmanager && !this.options.dropBehaviour) {
6110 dropped = $.ui.ddmanager.drop(this, event);
6111 }
6112
6113 //if a drop comes from outside (a sortable)
6114 if (this.dropped) {
6115 dropped = this.dropped;
6116 this.dropped = false;
6117 }
6118
6119 if ((this.options.revert === "invalid" && !dropped) || (this.options.revert === "valid" && dropped) || this.options.revert === true || ($.isFunction(this.options.revert) && this.options.revert.call(this.element, dropped))) {
6120 $(this.helper).animate(this.originalPosition, parseInt(this.options.revertDuration, 10), function() {
6121 if (that._trigger("stop", event) !== false) {
6122 that._clear();
6123 }
6124 });
6125 } else {
6126 if (this._trigger("stop", event) !== false) {
6127 this._clear();
6128 }
6129 }
6130
6131 return false;
6132 },
6133
6134 _mouseUp: function( event ) {
6135 this._unblockFrames();
6136
6137 //If the ddmanager is used for droppables, inform the manager that dragging has stopped (see #5003)
6138 if ( $.ui.ddmanager ) {
6139 $.ui.ddmanager.dragStop(this, event);
6140 }
6141
6142 // Only need to focus if the event occurred on the draggable itself, see #10527
6143 if ( this.handleElement.is( event.target ) ) {
6144 // The interaction is over; whether or not the click resulted in a drag, focus the element
6145 this.element.focus();
6146 }
6147
6148 return $.ui.mouse.prototype._mouseUp.call(this, event);
6149 },
6150
6151 cancel: function() {
6152
6153 if (this.helper.is(".ui-draggable-dragging")) {
6154 this._mouseUp({});
6155 } else {
6156 this._clear();
6157 }
6158
6159 return this;
6160
6161 },
6162
6163 _getHandle: function(event) {
6164 return this.options.handle ?
6165 !!$( event.target ).closest( this.element.find( this.options.handle ) ).length :
6166 true;
6167 },
6168
6169 _setHandleClassName: function() {
6170 this.handleElement = this.options.handle ?
6171 this.element.find( this.options.handle ) : this.element;
6172 this.handleElement.addClass( "ui-draggable-handle" );
6173 },
6174
6175 _removeHandleClassName: function() {
6176 this.handleElement.removeClass( "ui-draggable-handle" );
6177 },
6178
6179 _createHelper: function(event) {
6180
6181 var o = this.options,
6182 helperIsFunction = $.isFunction( o.helper ),
6183 helper = helperIsFunction ?
6184 $( o.helper.apply( this.element[ 0 ], [ event ] ) ) :
6185 ( o.helper === "clone" ?
6186 this.element.clone().removeAttr( "id" ) :
6187 this.element );
6188
6189 if (!helper.parents("body").length) {
6190 helper.appendTo((o.appendTo === "parent" ? this.element[0].parentNode : o.appendTo));
6191 }
6192
6193 // http://bugs.jqueryui.com/ticket/9446
6194 // a helper function can return the original element
6195 // which wouldn't have been set to relative in _create
6196 if ( helperIsFunction && helper[ 0 ] === this.element[ 0 ] ) {
6197 this._setPositionRelative();
6198 }
6199
6200 if (helper[0] !== this.element[0] && !(/(fixed|absolute)/).test(helper.css("position"))) {
6201 helper.css("position", "absolute");
6202 }
6203
6204 return helper;
6205
6206 },
6207
6208 _setPositionRelative: function() {
6209 if ( !( /^(?:r|a|f)/ ).test( this.element.css( "position" ) ) ) {
6210 this.element[ 0 ].style.position = "relative";
6211 }
6212 },
6213
6214 _adjustOffsetFromHelper: function(obj) {
6215 if (typeof obj === "string") {
6216 obj = obj.split(" ");
6217 }
6218 if ($.isArray(obj)) {
6219 obj = { left: +obj[0], top: +obj[1] || 0 };
6220 }
6221 if ("left" in obj) {
6222 this.offset.click.left = obj.left + this.margins.left;
6223 }
6224 if ("right" in obj) {
6225 this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
6226 }
6227 if ("top" in obj) {
6228 this.offset.click.top = obj.top + this.margins.top;
6229 }
6230 if ("bottom" in obj) {
6231 this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
6232 }
6233 },
6234
6235 _isRootNode: function( element ) {
6236 return ( /(html|body)/i ).test( element.tagName ) || element === this.document[ 0 ];
6237 },
6238
6239 _getParentOffset: function() {
6240
6241 //Get the offsetParent and cache its position
6242 var po = this.offsetParent.offset(),
6243 document = this.document[ 0 ];
6244
6245 // This is a special case where we need to modify a offset calculated on start, since the following happened:
6246 // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
6247 // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
6248 // the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
6249 if (this.cssPosition === "absolute" && this.scrollParent[0] !== document && $.contains(this.scrollParent[0], this.offsetParent[0])) {
6250 po.left += this.scrollParent.scrollLeft();
6251 po.top += this.scrollParent.scrollTop();
6252 }
6253
6254 if ( this._isRootNode( this.offsetParent[ 0 ] ) ) {
6255 po = { top: 0, left: 0 };
6256 }
6257
6258 return {
6259 top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"), 10) || 0),
6260 left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"), 10) || 0)
6261 };
6262
6263 },
6264
6265 _getRelativeOffset: function() {
6266 if ( this.cssPosition !== "relative" ) {
6267 return { top: 0, left: 0 };
6268 }
6269
6270 var p = this.element.position(),
6271 scrollIsRootNode = this._isRootNode( this.scrollParent[ 0 ] );
6272
6273 return {
6274 top: p.top - ( parseInt(this.helper.css( "top" ), 10) || 0 ) + ( !scrollIsRootNode ? this.scrollParent.scrollTop() : 0 ),
6275 left: p.left - ( parseInt(this.helper.css( "left" ), 10) || 0 ) + ( !scrollIsRootNode ? this.scrollParent.scrollLeft() : 0 )
6276 };
6277
6278 },
6279
6280 _cacheMargins: function() {
6281 this.margins = {
6282 left: (parseInt(this.element.css("marginLeft"), 10) || 0),
6283 top: (parseInt(this.element.css("marginTop"), 10) || 0),
6284 right: (parseInt(this.element.css("marginRight"), 10) || 0),
6285 bottom: (parseInt(this.element.css("marginBottom"), 10) || 0)
6286 };
6287 },
6288
6289 _cacheHelperProportions: function() {
6290 this.helperProportions = {
6291 width: this.helper.outerWidth(),
6292 height: this.helper.outerHeight()
6293 };
6294 },
6295
6296 _setContainment: function() {
6297
6298 var isUserScrollable, c, ce,
6299 o = this.options,
6300 document = this.document[ 0 ];
6301
6302 this.relativeContainer = null;
6303
6304 if ( !o.containment ) {
6305 this.containment = null;
6306 return;
6307 }
6308
6309 if ( o.containment === "window" ) {
6310 this.containment = [
6311 $( window ).scrollLeft() - this.offset.relative.left - this.offset.parent.left,
6312 $( window ).scrollTop() - this.offset.relative.top - this.offset.parent.top,
6313 $( window ).scrollLeft() + $( window ).width() - this.helperProportions.width - this.margins.left,
6314 $( window ).scrollTop() + ( $( window ).height() || document.body.parentNode.scrollHeight ) - this.helperProportions.height - this.margins.top
6315 ];
6316 return;
6317 }
6318
6319 if ( o.containment === "document") {
6320 this.containment = [
6321 0,
6322 0,
6323 $( document ).width() - this.helperProportions.width - this.margins.left,
6324 ( $( document ).height() || document.body.parentNode.scrollHeight ) - this.helperProportions.height - this.margins.top
6325 ];
6326 return;
6327 }
6328
6329 if ( o.containment.constructor === Array ) {
6330 this.containment = o.containment;
6331 return;
6332 }
6333
6334 if ( o.containment === "parent" ) {
6335 o.containment = this.helper[ 0 ].parentNode;
6336 }
6337
6338 c = $( o.containment );
6339 ce = c[ 0 ];
6340
6341 if ( !ce ) {
6342 return;
6343 }
6344
6345 isUserScrollable = /(scroll|auto)/.test( c.css( "overflow" ) );
6346
6347 this.containment = [
6348 ( parseInt( c.css( "borderLeftWidth" ), 10 ) || 0 ) + ( parseInt( c.css( "paddingLeft" ), 10 ) || 0 ),
6349 ( parseInt( c.css( "borderTopWidth" ), 10 ) || 0 ) + ( parseInt( c.css( "paddingTop" ), 10 ) || 0 ),
6350 ( isUserScrollable ? Math.max( ce.scrollWidth, ce.offsetWidth ) : ce.offsetWidth ) -
6351 ( parseInt( c.css( "borderRightWidth" ), 10 ) || 0 ) -
6352 ( parseInt( c.css( "paddingRight" ), 10 ) || 0 ) -
6353 this.helperProportions.width -
6354 this.margins.left -
6355 this.margins.right,
6356 ( isUserScrollable ? Math.max( ce.scrollHeight, ce.offsetHeight ) : ce.offsetHeight ) -
6357 ( parseInt( c.css( "borderBottomWidth" ), 10 ) || 0 ) -
6358 ( parseInt( c.css( "paddingBottom" ), 10 ) || 0 ) -
6359 this.helperProportions.height -
6360 this.margins.top -
6361 this.margins.bottom
6362 ];
6363 this.relativeContainer = c;
6364 },
6365
6366 _convertPositionTo: function(d, pos) {
6367
6368 if (!pos) {
6369 pos = this.position;
6370 }
6371
6372 var mod = d === "absolute" ? 1 : -1,
6373 scrollIsRootNode = this._isRootNode( this.scrollParent[ 0 ] );
6374
6375 return {
6376 top: (
6377 pos.top + // The absolute mouse position
6378 this.offset.relative.top * mod + // Only for relative positioned nodes: Relative offset from element to offset parent
6379 this.offset.parent.top * mod - // The offsetParent's offset without borders (offset + border)
6380 ( ( this.cssPosition === "fixed" ? -this.offset.scroll.top : ( scrollIsRootNode ? 0 : this.offset.scroll.top ) ) * mod)
6381 ),
6382 left: (
6383 pos.left + // The absolute mouse position
6384 this.offset.relative.left * mod + // Only for relative positioned nodes: Relative offset from element to offset parent
6385 this.offset.parent.left * mod - // The offsetParent's offset without borders (offset + border)
6386 ( ( this.cssPosition === "fixed" ? -this.offset.scroll.left : ( scrollIsRootNode ? 0 : this.offset.scroll.left ) ) * mod)
6387 )
6388 };
6389
6390 },
6391
6392 _generatePosition: function( event, constrainPosition ) {
6393
6394 var containment, co, top, left,
6395 o = this.options,
6396 scrollIsRootNode = this._isRootNode( this.scrollParent[ 0 ] ),
6397 pageX = event.pageX,
6398 pageY = event.pageY;
6399
6400 // Cache the scroll
6401 if ( !scrollIsRootNode || !this.offset.scroll ) {
6402 this.offset.scroll = {
6403 top: this.scrollParent.scrollTop(),
6404 left: this.scrollParent.scrollLeft()
6405 };
6406 }
6407
6408 /*
6409 * - Position constraining -
6410 * Constrain the position to a mix of grid, containment.
6411 */
6412
6413 // If we are not dragging yet, we won't check for options
6414 if ( constrainPosition ) {
6415 if ( this.containment ) {
6416 if ( this.relativeContainer ){
6417 co = this.relativeContainer.offset();
6418 containment = [
6419 this.containment[ 0 ] + co.left,
6420 this.containment[ 1 ] + co.top,
6421 this.containment[ 2 ] + co.left,
6422 this.containment[ 3 ] + co.top
6423 ];
6424 } else {
6425 containment = this.containment;
6426 }
6427
6428 if (event.pageX - this.offset.click.left < containment[0]) {
6429 pageX = containment[0] + this.offset.click.left;
6430 }
6431 if (event.pageY - this.offset.click.top < containment[1]) {
6432 pageY = containment[1] + this.offset.click.top;
6433 }
6434 if (event.pageX - this.offset.click.left > containment[2]) {
6435 pageX = containment[2] + this.offset.click.left;
6436 }
6437 if (event.pageY - this.offset.click.top > containment[3]) {
6438 pageY = containment[3] + this.offset.click.top;
6439 }
6440 }
6441
6442 if (o.grid) {
6443 //Check for grid elements set to 0 to prevent divide by 0 error causing invalid argument errors in IE (see ticket #6950)
6444 top = o.grid[1] ? this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1] : this.originalPageY;
6445 pageY = containment ? ((top - this.offset.click.top >= containment[1] || top - this.offset.click.top > containment[3]) ? top : ((top - this.offset.click.top >= containment[1]) ? top - o.grid[1] : top + o.grid[1])) : top;
6446
6447 left = o.grid[0] ? this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0] : this.originalPageX;
6448 pageX = containment ? ((left - this.offset.click.left >= containment[0] || left - this.offset.click.left > containment[2]) ? left : ((left - this.offset.click.left >= containment[0]) ? left - o.grid[0] : left + o.grid[0])) : left;
6449 }
6450
6451 if ( o.axis === "y" ) {
6452 pageX = this.originalPageX;
6453 }
6454
6455 if ( o.axis === "x" ) {
6456 pageY = this.originalPageY;
6457 }
6458 }
6459
6460 return {
6461 top: (
6462 pageY - // The absolute mouse position
6463 this.offset.click.top - // Click offset (relative to the element)
6464 this.offset.relative.top - // Only for relative positioned nodes: Relative offset from element to offset parent
6465 this.offset.parent.top + // The offsetParent's offset without borders (offset + border)
6466 ( this.cssPosition === "fixed" ? -this.offset.scroll.top : ( scrollIsRootNode ? 0 : this.offset.scroll.top ) )
6467 ),
6468 left: (
6469 pageX - // The absolute mouse position
6470 this.offset.click.left - // Click offset (relative to the element)
6471 this.offset.relative.left - // Only for relative positioned nodes: Relative offset from element to offset parent
6472 this.offset.parent.left + // The offsetParent's offset without borders (offset + border)
6473 ( this.cssPosition === "fixed" ? -this.offset.scroll.left : ( scrollIsRootNode ? 0 : this.offset.scroll.left ) )
6474 )
6475 };
6476
6477 },
6478
6479 _clear: function() {
6480 this.helper.removeClass("ui-draggable-dragging");
6481 if (this.helper[0] !== this.element[0] && !this.cancelHelperRemoval) {
6482 this.helper.remove();
6483 }
6484 this.helper = null;
6485 this.cancelHelperRemoval = false;
6486 if ( this.destroyOnClear ) {
6487 this.destroy();
6488 }
6489 },
6490
6491 _normalizeRightBottom: function() {
6492 if ( this.options.axis !== "y" && this.helper.css( "right" ) !== "auto" ) {
6493 this.helper.width( this.helper.width() );
6494 this.helper.css( "right", "auto" );
6495 }
6496 if ( this.options.axis !== "x" && this.helper.css( "bottom" ) !== "auto" ) {
6497 this.helper.height( this.helper.height() );
6498 this.helper.css( "bottom", "auto" );
6499 }
6500 },
6501
6502 // From now on bulk stuff - mainly helpers
6503
6504 _trigger: function( type, event, ui ) {
6505 ui = ui || this._uiHash();
6506 $.ui.plugin.call( this, type, [ event, ui, this ], true );
6507
6508 // Absolute position and offset (see #6884 ) have to be recalculated after plugins
6509 if ( /^(drag|start|stop)/.test( type ) ) {
6510 this.positionAbs = this._convertPositionTo( "absolute" );
6511 ui.offset = this.positionAbs;
6512 }
6513 return $.Widget.prototype._trigger.call( this, type, event, ui );
6514 },
6515
6516 plugins: {},
6517
6518 _uiHash: function() {
6519 return {
6520 helper: this.helper,
6521 position: this.position,
6522 originalPosition: this.originalPosition,
6523 offset: this.positionAbs
6524 };
6525 }
6526
6527 });
6528
6529 $.ui.plugin.add( "draggable", "connectToSortable", {
6530 start: function( event, ui, draggable ) {
6531 var uiSortable = $.extend( {}, ui, {
6532 item: draggable.element
6533 });
6534
6535 draggable.sortables = [];
6536 $( draggable.options.connectToSortable ).each(function() {
6537 var sortable = $( this ).sortable( "instance" );
6538
6539 if ( sortable && !sortable.options.disabled ) {
6540 draggable.sortables.push( sortable );
6541
6542 // refreshPositions is called at drag start to refresh the containerCache
6543 // which is used in drag. This ensures it's initialized and synchronized
6544 // with any changes that might have happened on the page since initialization.
6545 sortable.refreshPositions();
6546 sortable._trigger("activate", event, uiSortable);
6547 }
6548 });
6549 },
6550 stop: function( event, ui, draggable ) {
6551 var uiSortable = $.extend( {}, ui, {
6552 item: draggable.element
6553 });
6554
6555 draggable.cancelHelperRemoval = false;
6556
6557 $.each( draggable.sortables, function() {
6558 var sortable = this;
6559
6560 if ( sortable.isOver ) {
6561 sortable.isOver = 0;
6562
6563 // Allow this sortable to handle removing the helper
6564 draggable.cancelHelperRemoval = true;
6565 sortable.cancelHelperRemoval = false;
6566
6567 // Use _storedCSS To restore properties in the sortable,
6568 // as this also handles revert (#9675) since the draggable
6569 // may have modified them in unexpected ways (#8809)
6570 sortable._storedCSS = {
6571 position: sortable.placeholder.css( "position" ),
6572 top: sortable.placeholder.css( "top" ),
6573 left: sortable.placeholder.css( "left" )
6574 };
6575
6576 sortable._mouseStop(event);
6577
6578 // Once drag has ended, the sortable should return to using
6579 // its original helper, not the shared helper from draggable
6580 sortable.options.helper = sortable.options._helper;
6581 } else {
6582 // Prevent this Sortable from removing the helper.
6583 // However, don't set the draggable to remove the helper
6584 // either as another connected Sortable may yet handle the removal.
6585 sortable.cancelHelperRemoval = true;
6586
6587 sortable._trigger( "deactivate", event, uiSortable );
6588 }
6589 });
6590 },
6591 drag: function( event, ui, draggable ) {
6592 $.each( draggable.sortables, function() {
6593 var innermostIntersecting = false,
6594 sortable = this;
6595
6596 // Copy over variables that sortable's _intersectsWith uses
6597 sortable.positionAbs = draggable.positionAbs;
6598 sortable.helperProportions = draggable.helperProportions;
6599 sortable.offset.click = draggable.offset.click;
6600
6601 if ( sortable._intersectsWith( sortable.containerCache ) ) {
6602 innermostIntersecting = true;
6603
6604 $.each( draggable.sortables, function() {
6605 // Copy over variables that sortable's _intersectsWith uses
6606 this.positionAbs = draggable.positionAbs;
6607 this.helperProportions = draggable.helperProportions;
6608 this.offset.click = draggable.offset.click;
6609
6610 if ( this !== sortable &&
6611 this._intersectsWith( this.containerCache ) &&
6612 $.contains( sortable.element[ 0 ], this.element[ 0 ] ) ) {
6613 innermostIntersecting = false;
6614 }
6615
6616 return innermostIntersecting;
6617 });
6618 }
6619
6620 if ( innermostIntersecting ) {
6621 // If it intersects, we use a little isOver variable and set it once,
6622 // so that the move-in stuff gets fired only once.
6623 if ( !sortable.isOver ) {
6624 sortable.isOver = 1;
6625
6626 // Store draggable's parent in case we need to reappend to it later.
6627 draggable._parent = ui.helper.parent();
6628
6629 sortable.currentItem = ui.helper
6630 .appendTo( sortable.element )
6631 .data( "ui-sortable-item", true );
6632
6633 // Store helper option to later restore it
6634 sortable.options._helper = sortable.options.helper;
6635
6636 sortable.options.helper = function() {
6637 return ui.helper[ 0 ];
6638 };
6639
6640 // Fire the start events of the sortable with our passed browser event,
6641 // and our own helper (so it doesn't create a new one)
6642 event.target = sortable.currentItem[ 0 ];
6643 sortable._mouseCapture( event, true );
6644 sortable._mouseStart( event, true, true );
6645
6646 // Because the browser event is way off the new appended portlet,
6647 // modify necessary variables to reflect the changes
6648 sortable.offset.click.top = draggable.offset.click.top;
6649 sortable.offset.click.left = draggable.offset.click.left;
6650 sortable.offset.parent.left -= draggable.offset.parent.left -
6651 sortable.offset.parent.left;
6652 sortable.offset.parent.top -= draggable.offset.parent.top -
6653 sortable.offset.parent.top;
6654
6655 draggable._trigger( "toSortable", event );
6656
6657 // Inform draggable that the helper is in a valid drop zone,
6658 // used solely in the revert option to handle "valid/invalid".
6659 draggable.dropped = sortable.element;
6660
6661 // Need to refreshPositions of all sortables in the case that
6662 // adding to one sortable changes the location of the other sortables (#9675)
6663 $.each( draggable.sortables, function() {
6664 this.refreshPositions();
6665 });
6666
6667 // hack so receive/update callbacks work (mostly)
6668 draggable.currentItem = draggable.element;
6669 sortable.fromOutside = draggable;
6670 }
6671
6672 if ( sortable.currentItem ) {
6673 sortable._mouseDrag( event );
6674 // Copy the sortable's position because the draggable's can potentially reflect
6675 // a relative position, while sortable is always absolute, which the dragged
6676 // element has now become. (#8809)
6677 ui.position = sortable.position;
6678 }
6679 } else {
6680 // If it doesn't intersect with the sortable, and it intersected before,
6681 // we fake the drag stop of the sortable, but make sure it doesn't remove
6682 // the helper by using cancelHelperRemoval.
6683 if ( sortable.isOver ) {
6684
6685 sortable.isOver = 0;
6686 sortable.cancelHelperRemoval = true;
6687
6688 // Calling sortable's mouseStop would trigger a revert,
6689 // so revert must be temporarily false until after mouseStop is called.
6690 sortable.options._revert = sortable.options.revert;
6691 sortable.options.revert = false;
6692
6693 sortable._trigger( "out", event, sortable._uiHash( sortable ) );
6694 sortable._mouseStop( event, true );
6695
6696 // restore sortable behaviors that were modfied
6697 // when the draggable entered the sortable area (#9481)
6698 sortable.options.revert = sortable.options._revert;
6699 sortable.options.helper = sortable.options._helper;
6700
6701 if ( sortable.placeholder ) {
6702 sortable.placeholder.remove();
6703 }
6704
6705 // Restore and recalculate the draggable's offset considering the sortable
6706 // may have modified them in unexpected ways. (#8809, #10669)
6707 ui.helper.appendTo( draggable._parent );
6708 draggable._refreshOffsets( event );
6709 ui.position = draggable._generatePosition( event, true );
6710
6711 draggable._trigger( "fromSortable", event );
6712
6713 // Inform draggable that the helper is no longer in a valid drop zone
6714 draggable.dropped = false;
6715
6716 // Need to refreshPositions of all sortables just in case removing
6717 // from one sortable changes the location of other sortables (#9675)
6718 $.each( draggable.sortables, function() {
6719 this.refreshPositions();
6720 });
6721 }
6722 }
6723 });
6724 }
6725 });
6726
6727 $.ui.plugin.add("draggable", "cursor", {
6728 start: function( event, ui, instance ) {
6729 var t = $( "body" ),
6730 o = instance.options;
6731
6732 if (t.css("cursor")) {
6733 o._cursor = t.css("cursor");
6734 }
6735 t.css("cursor", o.cursor);
6736 },
6737 stop: function( event, ui, instance ) {
6738 var o = instance.options;
6739 if (o._cursor) {
6740 $("body").css("cursor", o._cursor);
6741 }
6742 }
6743 });
6744
6745 $.ui.plugin.add("draggable", "opacity", {
6746 start: function( event, ui, instance ) {
6747 var t = $( ui.helper ),
6748 o = instance.options;
6749 if (t.css("opacity")) {
6750 o._opacity = t.css("opacity");
6751 }
6752 t.css("opacity", o.opacity);
6753 },
6754 stop: function( event, ui, instance ) {
6755 var o = instance.options;
6756 if (o._opacity) {
6757 $(ui.helper).css("opacity", o._opacity);
6758 }
6759 }
6760 });
6761
6762 $.ui.plugin.add("draggable", "scroll", {
6763 start: function( event, ui, i ) {
6764 if ( !i.scrollParentNotHidden ) {
6765 i.scrollParentNotHidden = i.helper.scrollParent( false );
6766 }
6767
6768 if ( i.scrollParentNotHidden[ 0 ] !== i.document[ 0 ] && i.scrollParentNotHidden[ 0 ].tagName !== "HTML" ) {
6769 i.overflowOffset = i.scrollParentNotHidden.offset();
6770 }
6771 },
6772 drag: function( event, ui, i ) {
6773
6774 var o = i.options,
6775 scrolled = false,
6776 scrollParent = i.scrollParentNotHidden[ 0 ],
6777 document = i.document[ 0 ];
6778
6779 if ( scrollParent !== document && scrollParent.tagName !== "HTML" ) {
6780 if ( !o.axis || o.axis !== "x" ) {
6781 if ( ( i.overflowOffset.top + scrollParent.offsetHeight ) - event.pageY < o.scrollSensitivity ) {
6782 scrollParent.scrollTop = scrolled = scrollParent.scrollTop + o.scrollSpeed;
6783 } else if ( event.pageY - i.overflowOffset.top < o.scrollSensitivity ) {
6784 scrollParent.scrollTop = scrolled = scrollParent.scrollTop - o.scrollSpeed;
6785 }
6786 }
6787
6788 if ( !o.axis || o.axis !== "y" ) {
6789 if ( ( i.overflowOffset.left + scrollParent.offsetWidth ) - event.pageX < o.scrollSensitivity ) {
6790 scrollParent.scrollLeft = scrolled = scrollParent.scrollLeft + o.scrollSpeed;
6791 } else if ( event.pageX - i.overflowOffset.left < o.scrollSensitivity ) {
6792 scrollParent.scrollLeft = scrolled = scrollParent.scrollLeft - o.scrollSpeed;
6793 }
6794 }
6795
6796 } else {
6797
6798 if (!o.axis || o.axis !== "x") {
6799 if (event.pageY - $(document).scrollTop() < o.scrollSensitivity) {
6800 scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
6801 } else if ($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity) {
6802 scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
6803 }
6804 }
6805
6806 if (!o.axis || o.axis !== "y") {
6807 if (event.pageX - $(document).scrollLeft() < o.scrollSensitivity) {
6808 scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
6809 } else if ($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity) {
6810 scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
6811 }
6812 }
6813
6814 }
6815
6816 if (scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
6817 $.ui.ddmanager.prepareOffsets(i, event);
6818 }
6819
6820 }
6821 });
6822
6823 $.ui.plugin.add("draggable", "snap", {
6824 start: function( event, ui, i ) {
6825
6826 var o = i.options;
6827
6828 i.snapElements = [];
6829
6830 $(o.snap.constructor !== String ? ( o.snap.items || ":data(ui-draggable)" ) : o.snap).each(function() {
6831 var $t = $(this),
6832 $o = $t.offset();
6833 if (this !== i.element[0]) {
6834 i.snapElements.push({
6835 item: this,
6836 width: $t.outerWidth(), height: $t.outerHeight(),
6837 top: $o.top, left: $o.left
6838 });
6839 }
6840 });
6841
6842 },
6843 drag: function( event, ui, inst ) {
6844
6845 var ts, bs, ls, rs, l, r, t, b, i, first,
6846 o = inst.options,
6847 d = o.snapTolerance,
6848 x1 = ui.offset.left, x2 = x1 + inst.helperProportions.width,
6849 y1 = ui.offset.top, y2 = y1 + inst.helperProportions.height;
6850
6851 for (i = inst.snapElements.length - 1; i >= 0; i--){
6852
6853 l = inst.snapElements[i].left - inst.margins.left;
6854 r = l + inst.snapElements[i].width;
6855 t = inst.snapElements[i].top - inst.margins.top;
6856 b = t + inst.snapElements[i].height;
6857
6858 if ( x2 < l - d || x1 > r + d || y2 < t - d || y1 > b + d || !$.contains( inst.snapElements[ i ].item.ownerDocument, inst.snapElements[ i ].item ) ) {
6859 if (inst.snapElements[i].snapping) {
6860 (inst.options.snap.release && inst.options.snap.release.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
6861 }
6862 inst.snapElements[i].snapping = false;
6863 continue;
6864 }
6865
6866 if (o.snapMode !== "inner") {
6867 ts = Math.abs(t - y2) <= d;
6868 bs = Math.abs(b - y1) <= d;
6869 ls = Math.abs(l - x2) <= d;
6870 rs = Math.abs(r - x1) <= d;
6871 if (ts) {
6872 ui.position.top = inst._convertPositionTo("relative", { top: t - inst.helperProportions.height, left: 0 }).top;
6873 }
6874 if (bs) {
6875 ui.position.top = inst._convertPositionTo("relative", { top: b, left: 0 }).top;
6876 }
6877 if (ls) {
6878 ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l - inst.helperProportions.width }).left;
6879 }
6880 if (rs) {
6881 ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r }).left;
6882 }
6883 }
6884
6885 first = (ts || bs || ls || rs);
6886
6887 if (o.snapMode !== "outer") {
6888 ts = Math.abs(t - y1) <= d;
6889 bs = Math.abs(b - y2) <= d;
6890 ls = Math.abs(l - x1) <= d;
6891 rs = Math.abs(r - x2) <= d;
6892 if (ts) {
6893 ui.position.top = inst._convertPositionTo("relative", { top: t, left: 0 }).top;
6894 }
6895 if (bs) {
6896 ui.position.top = inst._convertPositionTo("relative", { top: b - inst.helperProportions.height, left: 0 }).top;
6897 }
6898 if (ls) {
6899 ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l }).left;
6900 }
6901 if (rs) {
6902 ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r - inst.helperProportions.width }).left;
6903 }
6904 }
6905
6906 if (!inst.snapElements[i].snapping && (ts || bs || ls || rs || first)) {
6907 (inst.options.snap.snap && inst.options.snap.snap.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
6908 }
6909 inst.snapElements[i].snapping = (ts || bs || ls || rs || first);
6910
6911 }
6912
6913 }
6914 });
6915
6916 $.ui.plugin.add("draggable", "stack", {
6917 start: function( event, ui, instance ) {
6918 var min,
6919 o = instance.options,
6920 group = $.makeArray($(o.stack)).sort(function(a, b) {
6921 return (parseInt($(a).css("zIndex"), 10) || 0) - (parseInt($(b).css("zIndex"), 10) || 0);
6922 });
6923
6924 if (!group.length) { return; }
6925
6926 min = parseInt($(group[0]).css("zIndex"), 10) || 0;
6927 $(group).each(function(i) {
6928 $(this).css("zIndex", min + i);
6929 });
6930 this.css("zIndex", (min + group.length));
6931 }
6932 });
6933
6934 $.ui.plugin.add("draggable", "zIndex", {
6935 start: function( event, ui, instance ) {
6936 var t = $( ui.helper ),
6937 o = instance.options;
6938
6939 if (t.css("zIndex")) {
6940 o._zIndex = t.css("zIndex");
6941 }
6942 t.css("zIndex", o.zIndex);
6943 },
6944 stop: function( event, ui, instance ) {
6945 var o = instance.options;
6946
6947 if (o._zIndex) {
6948 $(ui.helper).css("zIndex", o._zIndex);
6949 }
6950 }
6951 });
6952
6953 var draggable = $.ui.draggable;
6954
6955
6956 /*!
6957 * jQuery UI Resizable 1.11.4
6958 * http://jqueryui.com
6959 *
6960 * Copyright jQuery Foundation and other contributors
6961 * Released under the MIT license.
6962 * http://jquery.org/license
6963 *
6964 * http://api.jqueryui.com/resizable/
6965 */
6966
6967
6968 $.widget("ui.resizable", $.ui.mouse, {
6969 version: "1.11.4",
6970 widgetEventPrefix: "resize",
6971 options: {
6972 alsoResize: false,
6973 animate: false,
6974 animateDuration: "slow",
6975 animateEasing: "swing",
6976 aspectRatio: false,
6977 autoHide: false,
6978 containment: false,
6979 ghost: false,
6980 grid: false,
6981 handles: "e,s,se",
6982 helper: false,
6983 maxHeight: null,
6984 maxWidth: null,
6985 minHeight: 10,
6986 minWidth: 10,
6987 // See #7960
6988 zIndex: 90,
6989
6990 // callbacks
6991 resize: null,
6992 start: null,
6993 stop: null
6994 },
6995
6996 _num: function( value ) {
6997 return parseInt( value, 10 ) || 0;
6998 },
6999
7000 _isNumber: function( value ) {
7001 return !isNaN( parseInt( value, 10 ) );
7002 },
7003
7004 _hasScroll: function( el, a ) {
7005
7006 if ( $( el ).css( "overflow" ) === "hidden") {
7007 return false;
7008 }
7009
7010 var scroll = ( a && a === "left" ) ? "scrollLeft" : "scrollTop",
7011 has = false;
7012
7013 if ( el[ scroll ] > 0 ) {
7014 return true;
7015 }
7016
7017 // TODO: determine which cases actually cause this to happen
7018 // if the element doesn't have the scroll set, see if it's possible to
7019 // set the scroll
7020 el[ scroll ] = 1;
7021 has = ( el[ scroll ] > 0 );
7022 el[ scroll ] = 0;
7023 return has;
7024 },
7025
7026 _create: function() {
7027
7028 var n, i, handle, axis, hname,
7029 that = this,
7030 o = this.options;
7031 this.element.addClass("ui-resizable");
7032
7033 $.extend(this, {
7034 _aspectRatio: !!(o.aspectRatio),
7035 aspectRatio: o.aspectRatio,
7036 originalElement: this.element,
7037 _proportionallyResizeElements: [],
7038 _helper: o.helper || o.ghost || o.animate ? o.helper || "ui-resizable-helper" : null
7039 });
7040
7041 // Wrap the element if it cannot hold child nodes
7042 if (this.element[0].nodeName.match(/^(canvas|textarea|input|select|button|img)$/i)) {
7043
7044 this.element.wrap(
7045 $("<div class='ui-wrapper' style='overflow: hidden;'></div>").css({
7046 position: this.element.css("position"),
7047 width: this.element.outerWidth(),
7048 height: this.element.outerHeight(),
7049 top: this.element.css("top"),
7050 left: this.element.css("left")
7051 })
7052 );
7053
7054 this.element = this.element.parent().data(
7055 "ui-resizable", this.element.resizable( "instance" )
7056 );
7057
7058 this.elementIsWrapper = true;
7059
7060 this.element.css({
7061 marginLeft: this.originalElement.css("marginLeft"),
7062 marginTop: this.originalElement.css("marginTop"),
7063 marginRight: this.originalElement.css("marginRight"),
7064 marginBottom: this.originalElement.css("marginBottom")
7065 });
7066 this.originalElement.css({
7067 marginLeft: 0,
7068 marginTop: 0,
7069 marginRight: 0,
7070 marginBottom: 0
7071 });
7072 // support: Safari
7073 // Prevent Safari textarea resize
7074 this.originalResizeStyle = this.originalElement.css("resize");
7075 this.originalElement.css("resize", "none");
7076
7077 this._proportionallyResizeElements.push( this.originalElement.css({
7078 position: "static",
7079 zoom: 1,
7080 display: "block"
7081 }) );
7082
7083 // support: IE9
7084 // avoid IE jump (hard set the margin)
7085 this.originalElement.css({ margin: this.originalElement.css("margin") });
7086
7087 this._proportionallyResize();
7088 }
7089
7090 this.handles = o.handles ||
7091 ( !$(".ui-resizable-handle", this.element).length ?
7092 "e,s,se" : {
7093 n: ".ui-resizable-n",
7094 e: ".ui-resizable-e",
7095 s: ".ui-resizable-s",
7096 w: ".ui-resizable-w",
7097 se: ".ui-resizable-se",
7098 sw: ".ui-resizable-sw",
7099 ne: ".ui-resizable-ne",
7100 nw: ".ui-resizable-nw"
7101 } );
7102
7103 this._handles = $();
7104 if ( this.handles.constructor === String ) {
7105
7106 if ( this.handles === "all") {
7107 this.handles = "n,e,s,w,se,sw,ne,nw";
7108 }
7109
7110 n = this.handles.split(",");
7111 this.handles = {};
7112
7113 for (i = 0; i < n.length; i++) {
7114
7115 handle = $.trim(n[i]);
7116 hname = "ui-resizable-" + handle;
7117 axis = $("<div class='ui-resizable-handle " + hname + "'></div>");
7118
7119 axis.css({ zIndex: o.zIndex });
7120
7121 // TODO : What's going on here?
7122 if ("se" === handle) {
7123 axis.addClass("ui-icon ui-icon-gripsmall-diagonal-se");
7124 }
7125
7126 this.handles[handle] = ".ui-resizable-" + handle;
7127 this.element.append(axis);
7128 }
7129
7130 }
7131
7132 this._renderAxis = function(target) {
7133
7134 var i, axis, padPos, padWrapper;
7135
7136 target = target || this.element;
7137
7138 for (i in this.handles) {
7139
7140 if (this.handles[i].constructor === String) {
7141 this.handles[i] = this.element.children( this.handles[ i ] ).first().show();
7142 } else if ( this.handles[ i ].jquery || this.handles[ i ].nodeType ) {
7143 this.handles[ i ] = $( this.handles[ i ] );
7144 this._on( this.handles[ i ], { "mousedown": that._mouseDown });
7145 }
7146
7147 if (this.elementIsWrapper && this.originalElement[0].nodeName.match(/^(textarea|input|select|button)$/i)) {
7148
7149 axis = $(this.handles[i], this.element);
7150
7151 padWrapper = /sw|ne|nw|se|n|s/.test(i) ? axis.outerHeight() : axis.outerWidth();
7152
7153 padPos = [ "padding",
7154 /ne|nw|n/.test(i) ? "Top" :
7155 /se|sw|s/.test(i) ? "Bottom" :
7156 /^e$/.test(i) ? "Right" : "Left" ].join("");
7157
7158 target.css(padPos, padWrapper);
7159
7160 this._proportionallyResize();
7161 }
7162
7163 this._handles = this._handles.add( this.handles[ i ] );
7164 }
7165 };
7166
7167 // TODO: make renderAxis a prototype function
7168 this._renderAxis(this.element);
7169
7170 this._handles = this._handles.add( this.element.find( ".ui-resizable-handle" ) );
7171 this._handles.disableSelection();
7172
7173 this._handles.mouseover(function() {
7174 if (!that.resizing) {
7175 if (this.className) {
7176 axis = this.className.match(/ui-resizable-(se|sw|ne|nw|n|e|s|w)/i);
7177 }
7178 that.axis = axis && axis[1] ? axis[1] : "se";
7179 }
7180 });
7181
7182 if (o.autoHide) {
7183 this._handles.hide();
7184 $(this.element)
7185 .addClass("ui-resizable-autohide")
7186 .mouseenter(function() {
7187 if (o.disabled) {
7188 return;
7189 }
7190 $(this).removeClass("ui-resizable-autohide");
7191 that._handles.show();
7192 })
7193 .mouseleave(function() {
7194 if (o.disabled) {
7195 return;
7196 }
7197 if (!that.resizing) {
7198 $(this).addClass("ui-resizable-autohide");
7199 that._handles.hide();
7200 }
7201 });
7202 }
7203
7204 this._mouseInit();
7205 },
7206
7207 _destroy: function() {
7208
7209 this._mouseDestroy();
7210
7211 var wrapper,
7212 _destroy = function(exp) {
7213 $(exp)
7214 .removeClass("ui-resizable ui-resizable-disabled ui-resizable-resizing")
7215 .removeData("resizable")
7216 .removeData("ui-resizable")
7217 .unbind(".resizable")
7218 .find(".ui-resizable-handle")
7219 .remove();
7220 };
7221
7222 // TODO: Unwrap at same DOM position
7223 if (this.elementIsWrapper) {
7224 _destroy(this.element);
7225 wrapper = this.element;
7226 this.originalElement.css({
7227 position: wrapper.css("position"),
7228 width: wrapper.outerWidth(),
7229 height: wrapper.outerHeight(),
7230 top: wrapper.css("top"),
7231 left: wrapper.css("left")
7232 }).insertAfter( wrapper );
7233 wrapper.remove();
7234 }
7235
7236 this.originalElement.css("resize", this.originalResizeStyle);
7237 _destroy(this.originalElement);
7238
7239 return this;
7240 },
7241
7242 _mouseCapture: function(event) {
7243 var i, handle,
7244 capture = false;
7245
7246 for (i in this.handles) {
7247 handle = $(this.handles[i])[0];
7248 if (handle === event.target || $.contains(handle, event.target)) {
7249 capture = true;
7250 }
7251 }
7252
7253 return !this.options.disabled && capture;
7254 },
7255
7256 _mouseStart: function(event) {
7257
7258 var curleft, curtop, cursor,
7259 o = this.options,
7260 el = this.element;
7261
7262 this.resizing = true;
7263
7264 this._renderProxy();
7265
7266 curleft = this._num(this.helper.css("left"));
7267 curtop = this._num(this.helper.css("top"));
7268
7269 if (o.containment) {
7270 curleft += $(o.containment).scrollLeft() || 0;
7271 curtop += $(o.containment).scrollTop() || 0;
7272 }
7273
7274 this.offset = this.helper.offset();
7275 this.position = { left: curleft, top: curtop };
7276
7277 this.size = this._helper ? {
7278 width: this.helper.width(),
7279 height: this.helper.height()
7280 } : {
7281 width: el.width(),
7282 height: el.height()
7283 };
7284
7285 this.originalSize = this._helper ? {
7286 width: el.outerWidth(),
7287 height: el.outerHeight()
7288 } : {
7289 width: el.width(),
7290 height: el.height()
7291 };
7292
7293 this.sizeDiff = {
7294 width: el.outerWidth() - el.width(),
7295 height: el.outerHeight() - el.height()
7296 };
7297
7298 this.originalPosition = { left: curleft, top: curtop };
7299 this.originalMousePosition = { left: event.pageX, top: event.pageY };
7300
7301 this.aspectRatio = (typeof o.aspectRatio === "number") ?
7302 o.aspectRatio :
7303 ((this.originalSize.width / this.originalSize.height) || 1);
7304
7305 cursor = $(".ui-resizable-" + this.axis).css("cursor");
7306 $("body").css("cursor", cursor === "auto" ? this.axis + "-resize" : cursor);
7307
7308 el.addClass("ui-resizable-resizing");
7309 this._propagate("start", event);
7310 return true;
7311 },
7312
7313 _mouseDrag: function(event) {
7314
7315 var data, props,
7316 smp = this.originalMousePosition,
7317 a = this.axis,
7318 dx = (event.pageX - smp.left) || 0,
7319 dy = (event.pageY - smp.top) || 0,
7320 trigger = this._change[a];
7321
7322 this._updatePrevProperties();
7323
7324 if (!trigger) {
7325 return false;
7326 }
7327
7328 data = trigger.apply(this, [ event, dx, dy ]);
7329
7330 this._updateVirtualBoundaries(event.shiftKey);
7331 if (this._aspectRatio || event.shiftKey) {
7332 data = this._updateRatio(data, event);
7333 }
7334
7335 data = this._respectSize(data, event);
7336
7337 this._updateCache(data);
7338
7339 this._propagate("resize", event);
7340
7341 props = this._applyChanges();
7342
7343 if ( !this._helper && this._proportionallyResizeElements.length ) {
7344 this._proportionallyResize();
7345 }
7346
7347 if ( !$.isEmptyObject( props ) ) {
7348 this._updatePrevProperties();
7349 this._trigger( "resize", event, this.ui() );
7350 this._applyChanges();
7351 }
7352
7353 return false;
7354 },
7355
7356 _mouseStop: function(event) {
7357
7358 this.resizing = false;
7359 var pr, ista, soffseth, soffsetw, s, left, top,
7360 o = this.options, that = this;
7361
7362 if (this._helper) {
7363
7364 pr = this._proportionallyResizeElements;
7365 ista = pr.length && (/textarea/i).test(pr[0].nodeName);
7366 soffseth = ista && this._hasScroll(pr[0], "left") ? 0 : that.sizeDiff.height;
7367 soffsetw = ista ? 0 : that.sizeDiff.width;
7368
7369 s = {
7370 width: (that.helper.width() - soffsetw),
7371 height: (that.helper.height() - soffseth)
7372 };
7373 left = (parseInt(that.element.css("left"), 10) +
7374 (that.position.left - that.originalPosition.left)) || null;
7375 top = (parseInt(that.element.css("top"), 10) +
7376 (that.position.top - that.originalPosition.top)) || null;
7377
7378 if (!o.animate) {
7379 this.element.css($.extend(s, { top: top, left: left }));
7380 }
7381
7382 that.helper.height(that.size.height);
7383 that.helper.width(that.size.width);
7384
7385 if (this._helper && !o.animate) {
7386 this._proportionallyResize();
7387 }
7388 }
7389
7390 $("body").css("cursor", "auto");
7391
7392 this.element.removeClass("ui-resizable-resizing");
7393
7394 this._propagate("stop", event);
7395
7396 if (this._helper) {
7397 this.helper.remove();
7398 }
7399
7400 return false;
7401
7402 },
7403
7404 _updatePrevProperties: function() {
7405 this.prevPosition = {
7406 top: this.position.top,
7407 left: this.position.left
7408 };
7409 this.prevSize = {
7410 width: this.size.width,
7411 height: this.size.height
7412 };
7413 },
7414
7415 _applyChanges: function() {
7416 var props = {};
7417
7418 if ( this.position.top !== this.prevPosition.top ) {
7419 props.top = this.position.top + "px";
7420 }
7421 if ( this.position.left !== this.prevPosition.left ) {
7422 props.left = this.position.left + "px";
7423 }
7424 if ( this.size.width !== this.prevSize.width ) {
7425 props.width = this.size.width + "px";
7426 }
7427 if ( this.size.height !== this.prevSize.height ) {
7428 props.height = this.size.height + "px";
7429 }
7430
7431 this.helper.css( props );
7432
7433 return props;
7434 },
7435
7436 _updateVirtualBoundaries: function(forceAspectRatio) {
7437 var pMinWidth, pMaxWidth, pMinHeight, pMaxHeight, b,
7438 o = this.options;
7439
7440 b = {
7441 minWidth: this._isNumber(o.minWidth) ? o.minWidth : 0,
7442 maxWidth: this._isNumber(o.maxWidth) ? o.maxWidth : Infinity,
7443 minHeight: this._isNumber(o.minHeight) ? o.minHeight : 0,
7444 maxHeight: this._isNumber(o.maxHeight) ? o.maxHeight : Infinity
7445 };
7446
7447 if (this._aspectRatio || forceAspectRatio) {
7448 pMinWidth = b.minHeight * this.aspectRatio;
7449 pMinHeight = b.minWidth / this.aspectRatio;
7450 pMaxWidth = b.maxHeight * this.aspectRatio;
7451 pMaxHeight = b.maxWidth / this.aspectRatio;
7452
7453 if (pMinWidth > b.minWidth) {
7454 b.minWidth = pMinWidth;
7455 }
7456 if (pMinHeight > b.minHeight) {
7457 b.minHeight = pMinHeight;
7458 }
7459 if (pMaxWidth < b.maxWidth) {
7460 b.maxWidth = pMaxWidth;
7461 }
7462 if (pMaxHeight < b.maxHeight) {
7463 b.maxHeight = pMaxHeight;
7464 }
7465 }
7466 this._vBoundaries = b;
7467 },
7468
7469 _updateCache: function(data) {
7470 this.offset = this.helper.offset();
7471 if (this._isNumber(data.left)) {
7472 this.position.left = data.left;
7473 }
7474 if (this._isNumber(data.top)) {
7475 this.position.top = data.top;
7476 }
7477 if (this._isNumber(data.height)) {
7478 this.size.height = data.height;
7479 }
7480 if (this._isNumber(data.width)) {
7481 this.size.width = data.width;
7482 }
7483 },
7484
7485 _updateRatio: function( data ) {
7486
7487 var cpos = this.position,
7488 csize = this.size,
7489 a = this.axis;
7490
7491 if (this._isNumber(data.height)) {
7492 data.width = (data.height * this.aspectRatio);
7493 } else if (this._isNumber(data.width)) {
7494 data.height = (data.width / this.aspectRatio);
7495 }
7496
7497 if (a === "sw") {
7498 data.left = cpos.left + (csize.width - data.width);
7499 data.top = null;
7500 }
7501 if (a === "nw") {
7502 data.top = cpos.top + (csize.height - data.height);
7503 data.left = cpos.left + (csize.width - data.width);
7504 }
7505
7506 return data;
7507 },
7508
7509 _respectSize: function( data ) {
7510
7511 var o = this._vBoundaries,
7512 a = this.axis,
7513 ismaxw = this._isNumber(data.width) && o.maxWidth && (o.maxWidth < data.width),
7514 ismaxh = this._isNumber(data.height) && o.maxHeight && (o.maxHeight < data.height),
7515 isminw = this._isNumber(data.width) && o.minWidth && (o.minWidth > data.width),
7516 isminh = this._isNumber(data.height) && o.minHeight && (o.minHeight > data.height),
7517 dw = this.originalPosition.left + this.originalSize.width,
7518 dh = this.position.top + this.size.height,
7519 cw = /sw|nw|w/.test(a), ch = /nw|ne|n/.test(a);
7520 if (isminw) {
7521 data.width = o.minWidth;
7522 }
7523 if (isminh) {
7524 data.height = o.minHeight;
7525 }
7526 if (ismaxw) {
7527 data.width = o.maxWidth;
7528 }
7529 if (ismaxh) {
7530 data.height = o.maxHeight;
7531 }
7532
7533 if (isminw && cw) {
7534 data.left = dw - o.minWidth;
7535 }
7536 if (ismaxw && cw) {
7537 data.left = dw - o.maxWidth;
7538 }
7539 if (isminh && ch) {
7540 data.top = dh - o.minHeight;
7541 }
7542 if (ismaxh && ch) {
7543 data.top = dh - o.maxHeight;
7544 }
7545
7546 // Fixing jump error on top/left - bug #2330
7547 if (!data.width && !data.height && !data.left && data.top) {
7548 data.top = null;
7549 } else if (!data.width && !data.height && !data.top && data.left) {
7550 data.left = null;
7551 }
7552
7553 return data;
7554 },
7555
7556 _getPaddingPlusBorderDimensions: function( element ) {
7557 var i = 0,
7558 widths = [],
7559 borders = [
7560 element.css( "borderTopWidth" ),
7561 element.css( "borderRightWidth" ),
7562 element.css( "borderBottomWidth" ),
7563 element.css( "borderLeftWidth" )
7564 ],
7565 paddings = [
7566 element.css( "paddingTop" ),
7567 element.css( "paddingRight" ),
7568 element.css( "paddingBottom" ),
7569 element.css( "paddingLeft" )
7570 ];
7571
7572 for ( ; i < 4; i++ ) {
7573 widths[ i ] = ( parseInt( borders[ i ], 10 ) || 0 );
7574 widths[ i ] += ( parseInt( paddings[ i ], 10 ) || 0 );
7575 }
7576
7577 return {
7578 height: widths[ 0 ] + widths[ 2 ],
7579 width: widths[ 1 ] + widths[ 3 ]
7580 };
7581 },
7582
7583 _proportionallyResize: function() {
7584
7585 if (!this._proportionallyResizeElements.length) {
7586 return;
7587 }
7588
7589 var prel,
7590 i = 0,
7591 element = this.helper || this.element;
7592
7593 for ( ; i < this._proportionallyResizeElements.length; i++) {
7594
7595 prel = this._proportionallyResizeElements[i];
7596
7597 // TODO: Seems like a bug to cache this.outerDimensions
7598 // considering that we are in a loop.
7599 if (!this.outerDimensions) {
7600 this.outerDimensions = this._getPaddingPlusBorderDimensions( prel );
7601 }
7602
7603 prel.css({
7604 height: (element.height() - this.outerDimensions.height) || 0,
7605 width: (element.width() - this.outerDimensions.width) || 0
7606 });
7607
7608 }
7609
7610 },
7611
7612 _renderProxy: function() {
7613
7614 var el = this.element, o = this.options;
7615 this.elementOffset = el.offset();
7616
7617 if (this._helper) {
7618
7619 this.helper = this.helper || $("<div style='overflow:hidden;'></div>");
7620
7621 this.helper.addClass(this._helper).css({
7622 width: this.element.outerWidth() - 1,
7623 height: this.element.outerHeight() - 1,
7624 position: "absolute",
7625 left: this.elementOffset.left + "px",
7626 top: this.elementOffset.top + "px",
7627 zIndex: ++o.zIndex //TODO: Don't modify option
7628 });
7629
7630 this.helper
7631 .appendTo("body")
7632 .disableSelection();
7633
7634 } else {
7635 this.helper = this.element;
7636 }
7637
7638 },
7639
7640 _change: {
7641 e: function(event, dx) {
7642 return { width: this.originalSize.width + dx };
7643 },
7644 w: function(event, dx) {
7645 var cs = this.originalSize, sp = this.originalPosition;
7646 return { left: sp.left + dx, width: cs.width - dx };
7647 },
7648 n: function(event, dx, dy) {
7649 var cs = this.originalSize, sp = this.originalPosition;
7650 return { top: sp.top + dy, height: cs.height - dy };
7651 },
7652 s: function(event, dx, dy) {
7653 return { height: this.originalSize.height + dy };
7654 },
7655 se: function(event, dx, dy) {
7656 return $.extend(this._change.s.apply(this, arguments),
7657 this._change.e.apply(this, [ event, dx, dy ]));
7658 },
7659 sw: function(event, dx, dy) {
7660 return $.extend(this._change.s.apply(this, arguments),
7661 this._change.w.apply(this, [ event, dx, dy ]));
7662 },
7663 ne: function(event, dx, dy) {
7664 return $.extend(this._change.n.apply(this, arguments),
7665 this._change.e.apply(this, [ event, dx, dy ]));
7666 },
7667 nw: function(event, dx, dy) {
7668 return $.extend(this._change.n.apply(this, arguments),
7669 this._change.w.apply(this, [ event, dx, dy ]));
7670 }
7671 },
7672
7673 _propagate: function(n, event) {
7674 $.ui.plugin.call(this, n, [ event, this.ui() ]);
7675 (n !== "resize" && this._trigger(n, event, this.ui()));
7676 },
7677
7678 plugins: {},
7679
7680 ui: function() {
7681 return {
7682 originalElement: this.originalElement,
7683 element: this.element,
7684 helper: this.helper,
7685 position: this.position,
7686 size: this.size,
7687 originalSize: this.originalSize,
7688 originalPosition: this.originalPosition
7689 };
7690 }
7691
7692 });
7693
7694 /*
7695 * Resizable Extensions
7696 */
7697
7698 $.ui.plugin.add("resizable", "animate", {
7699
7700 stop: function( event ) {
7701 var that = $(this).resizable( "instance" ),
7702 o = that.options,
7703 pr = that._proportionallyResizeElements,
7704 ista = pr.length && (/textarea/i).test(pr[0].nodeName),
7705 soffseth = ista && that._hasScroll(pr[0], "left") ? 0 : that.sizeDiff.height,
7706 soffsetw = ista ? 0 : that.sizeDiff.width,
7707 style = { width: (that.size.width - soffsetw), height: (that.size.height - soffseth) },
7708 left = (parseInt(that.element.css("left"), 10) +
7709 (that.position.left - that.originalPosition.left)) || null,
7710 top = (parseInt(that.element.css("top"), 10) +
7711 (that.position.top - that.originalPosition.top)) || null;
7712
7713 that.element.animate(
7714 $.extend(style, top && left ? { top: top, left: left } : {}), {
7715 duration: o.animateDuration,
7716 easing: o.animateEasing,
7717 step: function() {
7718
7719 var data = {
7720 width: parseInt(that.element.css("width"), 10),
7721 height: parseInt(that.element.css("height"), 10),
7722 top: parseInt(that.element.css("top"), 10),
7723 left: parseInt(that.element.css("left"), 10)
7724 };
7725
7726 if (pr && pr.length) {
7727 $(pr[0]).css({ width: data.width, height: data.height });
7728 }
7729
7730 // propagating resize, and updating values for each animation step
7731 that._updateCache(data);
7732 that._propagate("resize", event);
7733
7734 }
7735 }
7736 );
7737 }
7738
7739 });
7740
7741 $.ui.plugin.add( "resizable", "containment", {
7742
7743 start: function() {
7744 var element, p, co, ch, cw, width, height,
7745 that = $( this ).resizable( "instance" ),
7746 o = that.options,
7747 el = that.element,
7748 oc = o.containment,
7749 ce = ( oc instanceof $ ) ? oc.get( 0 ) : ( /parent/.test( oc ) ) ? el.parent().get( 0 ) : oc;
7750
7751 if ( !ce ) {
7752 return;
7753 }
7754
7755 that.containerElement = $( ce );
7756
7757 if ( /document/.test( oc ) || oc === document ) {
7758 that.containerOffset = {
7759 left: 0,
7760 top: 0
7761 };
7762 that.containerPosition = {
7763 left: 0,
7764 top: 0
7765 };
7766
7767 that.parentData = {
7768 element: $( document ),
7769 left: 0,
7770 top: 0,
7771 width: $( document ).width(),
7772 height: $( document ).height() || document.body.parentNode.scrollHeight
7773 };
7774 } else {
7775 element = $( ce );
7776 p = [];
7777 $([ "Top", "Right", "Left", "Bottom" ]).each(function( i, name ) {
7778 p[ i ] = that._num( element.css( "padding" + name ) );
7779 });
7780
7781 that.containerOffset = element.offset();
7782 that.containerPosition = element.position();
7783 that.containerSize = {
7784 height: ( element.innerHeight() - p[ 3 ] ),
7785 width: ( element.innerWidth() - p[ 1 ] )
7786 };
7787
7788 co = that.containerOffset;
7789 ch = that.containerSize.height;
7790 cw = that.containerSize.width;
7791 width = ( that._hasScroll ( ce, "left" ) ? ce.scrollWidth : cw );
7792 height = ( that._hasScroll ( ce ) ? ce.scrollHeight : ch ) ;
7793
7794 that.parentData = {
7795 element: ce,
7796 left: co.left,
7797 top: co.top,
7798 width: width,
7799 height: height
7800 };
7801 }
7802 },
7803
7804 resize: function( event ) {
7805 var woset, hoset, isParent, isOffsetRelative,
7806 that = $( this ).resizable( "instance" ),
7807 o = that.options,
7808 co = that.containerOffset,
7809 cp = that.position,
7810 pRatio = that._aspectRatio || event.shiftKey,
7811 cop = {
7812 top: 0,
7813 left: 0
7814 },
7815 ce = that.containerElement,
7816 continueResize = true;
7817
7818 if ( ce[ 0 ] !== document && ( /static/ ).test( ce.css( "position" ) ) ) {
7819 cop = co;
7820 }
7821
7822 if ( cp.left < ( that._helper ? co.left : 0 ) ) {
7823 that.size.width = that.size.width +
7824 ( that._helper ?
7825 ( that.position.left - co.left ) :
7826 ( that.position.left - cop.left ) );
7827
7828 if ( pRatio ) {
7829 that.size.height = that.size.width / that.aspectRatio;
7830 continueResize = false;
7831 }
7832 that.position.left = o.helper ? co.left : 0;
7833 }
7834
7835 if ( cp.top < ( that._helper ? co.top : 0 ) ) {
7836 that.size.height = that.size.height +
7837 ( that._helper ?
7838 ( that.position.top - co.top ) :
7839 that.position.top );
7840
7841 if ( pRatio ) {
7842 that.size.width = that.size.height * that.aspectRatio;
7843 continueResize = false;
7844 }
7845 that.position.top = that._helper ? co.top : 0;
7846 }
7847
7848 isParent = that.containerElement.get( 0 ) === that.element.parent().get( 0 );
7849 isOffsetRelative = /relative|absolute/.test( that.containerElement.css( "position" ) );
7850
7851 if ( isParent && isOffsetRelative ) {
7852 that.offset.left = that.parentData.left + that.position.left;
7853 that.offset.top = that.parentData.top + that.position.top;
7854 } else {
7855 that.offset.left = that.element.offset().left;
7856 that.offset.top = that.element.offset().top;
7857 }
7858
7859 woset = Math.abs( that.sizeDiff.width +
7860 (that._helper ?
7861 that.offset.left - cop.left :
7862 (that.offset.left - co.left)) );
7863
7864 hoset = Math.abs( that.sizeDiff.height +
7865 (that._helper ?
7866 that.offset.top - cop.top :
7867 (that.offset.top - co.top)) );
7868
7869 if ( woset + that.size.width >= that.parentData.width ) {
7870 that.size.width = that.parentData.width - woset;
7871 if ( pRatio ) {
7872 that.size.height = that.size.width / that.aspectRatio;
7873 continueResize = false;
7874 }
7875 }
7876
7877 if ( hoset + that.size.height >= that.parentData.height ) {
7878 that.size.height = that.parentData.height - hoset;
7879 if ( pRatio ) {
7880 that.size.width = that.size.height * that.aspectRatio;
7881 continueResize = false;
7882 }
7883 }
7884
7885 if ( !continueResize ) {
7886 that.position.left = that.prevPosition.left;
7887 that.position.top = that.prevPosition.top;
7888 that.size.width = that.prevSize.width;
7889 that.size.height = that.prevSize.height;
7890 }
7891 },
7892
7893 stop: function() {
7894 var that = $( this ).resizable( "instance" ),
7895 o = that.options,
7896 co = that.containerOffset,
7897 cop = that.containerPosition,
7898 ce = that.containerElement,
7899 helper = $( that.helper ),
7900 ho = helper.offset(),
7901 w = helper.outerWidth() - that.sizeDiff.width,
7902 h = helper.outerHeight() - that.sizeDiff.height;
7903
7904 if ( that._helper && !o.animate && ( /relative/ ).test( ce.css( "position" ) ) ) {
7905 $( this ).css({
7906 left: ho.left - cop.left - co.left,
7907 width: w,
7908 height: h
7909 });
7910 }
7911
7912 if ( that._helper && !o.animate && ( /static/ ).test( ce.css( "position" ) ) ) {
7913 $( this ).css({
7914 left: ho.left - cop.left - co.left,
7915 width: w,
7916 height: h
7917 });
7918 }
7919 }
7920 });
7921
7922 $.ui.plugin.add("resizable", "alsoResize", {
7923
7924 start: function() {
7925 var that = $(this).resizable( "instance" ),
7926 o = that.options;
7927
7928 $(o.alsoResize).each(function() {
7929 var el = $(this);
7930 el.data("ui-resizable-alsoresize", {
7931 width: parseInt(el.width(), 10), height: parseInt(el.height(), 10),
7932 left: parseInt(el.css("left"), 10), top: parseInt(el.css("top"), 10)
7933 });
7934 });
7935 },
7936
7937 resize: function(event, ui) {
7938 var that = $(this).resizable( "instance" ),
7939 o = that.options,
7940 os = that.originalSize,
7941 op = that.originalPosition,
7942 delta = {
7943 height: (that.size.height - os.height) || 0,
7944 width: (that.size.width - os.width) || 0,
7945 top: (that.position.top - op.top) || 0,
7946 left: (that.position.left - op.left) || 0
7947 };
7948
7949 $(o.alsoResize).each(function() {
7950 var el = $(this), start = $(this).data("ui-resizable-alsoresize"), style = {},
7951 css = el.parents(ui.originalElement[0]).length ?
7952 [ "width", "height" ] :
7953 [ "width", "height", "top", "left" ];
7954
7955 $.each(css, function(i, prop) {
7956 var sum = (start[prop] || 0) + (delta[prop] || 0);
7957 if (sum && sum >= 0) {
7958 style[prop] = sum || null;
7959 }
7960 });
7961
7962 el.css(style);
7963 });
7964 },
7965
7966 stop: function() {
7967 $(this).removeData("resizable-alsoresize");
7968 }
7969 });
7970
7971 $.ui.plugin.add("resizable", "ghost", {
7972
7973 start: function() {
7974
7975 var that = $(this).resizable( "instance" ), o = that.options, cs = that.size;
7976
7977 that.ghost = that.originalElement.clone();
7978 that.ghost
7979 .css({
7980 opacity: 0.25,
7981 display: "block",
7982 position: "relative",
7983 height: cs.height,
7984 width: cs.width,
7985 margin: 0,
7986 left: 0,
7987 top: 0
7988 })
7989 .addClass("ui-resizable-ghost")
7990 .addClass(typeof o.ghost === "string" ? o.ghost : "");
7991
7992 that.ghost.appendTo(that.helper);
7993
7994 },
7995
7996 resize: function() {
7997 var that = $(this).resizable( "instance" );
7998 if (that.ghost) {
7999 that.ghost.css({
8000 position: "relative",
8001 height: that.size.height,
8002 width: that.size.width
8003 });
8004 }
8005 },
8006
8007 stop: function() {
8008 var that = $(this).resizable( "instance" );
8009 if (that.ghost && that.helper) {
8010 that.helper.get(0).removeChild(that.ghost.get(0));
8011 }
8012 }
8013
8014 });
8015
8016 $.ui.plugin.add("resizable", "grid", {
8017
8018 resize: function() {
8019 var outerDimensions,
8020 that = $(this).resizable( "instance" ),
8021 o = that.options,
8022 cs = that.size,
8023 os = that.originalSize,
8024 op = that.originalPosition,
8025 a = that.axis,
8026 grid = typeof o.grid === "number" ? [ o.grid, o.grid ] : o.grid,
8027 gridX = (grid[0] || 1),
8028 gridY = (grid[1] || 1),
8029 ox = Math.round((cs.width - os.width) / gridX) * gridX,
8030 oy = Math.round((cs.height - os.height) / gridY) * gridY,
8031 newWidth = os.width + ox,
8032 newHeight = os.height + oy,
8033 isMaxWidth = o.maxWidth && (o.maxWidth < newWidth),
8034 isMaxHeight = o.maxHeight && (o.maxHeight < newHeight),
8035 isMinWidth = o.minWidth && (o.minWidth > newWidth),
8036 isMinHeight = o.minHeight && (o.minHeight > newHeight);
8037
8038 o.grid = grid;
8039
8040 if (isMinWidth) {
8041 newWidth += gridX;
8042 }
8043 if (isMinHeight) {
8044 newHeight += gridY;
8045 }
8046 if (isMaxWidth) {
8047 newWidth -= gridX;
8048 }
8049 if (isMaxHeight) {
8050 newHeight -= gridY;
8051 }
8052
8053 if (/^(se|s|e)$/.test(a)) {
8054 that.size.width = newWidth;
8055 that.size.height = newHeight;
8056 } else if (/^(ne)$/.test(a)) {
8057 that.size.width = newWidth;
8058 that.size.height = newHeight;
8059 that.position.top = op.top - oy;
8060 } else if (/^(sw)$/.test(a)) {
8061 that.size.width = newWidth;
8062 that.size.height = newHeight;
8063 that.position.left = op.left - ox;
8064 } else {
8065 if ( newHeight - gridY <= 0 || newWidth - gridX <= 0) {
8066 outerDimensions = that._getPaddingPlusBorderDimensions( this );
8067 }
8068
8069 if ( newHeight - gridY > 0 ) {
8070 that.size.height = newHeight;
8071 that.position.top = op.top - oy;
8072 } else {
8073 newHeight = gridY - outerDimensions.height;
8074 that.size.height = newHeight;
8075 that.position.top = op.top + os.height - newHeight;
8076 }
8077 if ( newWidth - gridX > 0 ) {
8078 that.size.width = newWidth;
8079 that.position.left = op.left - ox;
8080 } else {
8081 newWidth = gridX - outerDimensions.width;
8082 that.size.width = newWidth;
8083 that.position.left = op.left + os.width - newWidth;
8084 }
8085 }
8086 }
8087
8088 });
8089
8090 var resizable = $.ui.resizable;
8091
8092
8093 /*!
8094 * jQuery UI Dialog 1.11.4
8095 * http://jqueryui.com
8096 *
8097 * Copyright jQuery Foundation and other contributors
8098 * Released under the MIT license.
8099 * http://jquery.org/license
8100 *
8101 * http://api.jqueryui.com/dialog/
8102 */
8103
8104
8105 var dialog = $.widget( "ui.dialog", {
8106 version: "1.11.4",
8107 options: {
8108 appendTo: "body",
8109 autoOpen: true,
8110 buttons: [],
8111 closeOnEscape: true,
8112 closeText: "Close",
8113 dialogClass: "",
8114 draggable: true,
8115 hide: null,
8116 height: "auto",
8117 maxHeight: null,
8118 maxWidth: null,
8119 minHeight: 150,
8120 minWidth: 150,
8121 modal: false,
8122 position: {
8123 my: "center",
8124 at: "center",
8125 of: window,
8126 collision: "fit",
8127 // Ensure the titlebar is always visible
8128 using: function( pos ) {
8129 var topOffset = $( this ).css( pos ).offset().top;
8130 if ( topOffset < 0 ) {
8131 $( this ).css( "top", pos.top - topOffset );
8132 }
8133 }
8134 },
8135 resizable: true,
8136 show: null,
8137 title: null,
8138 width: 300,
8139
8140 // callbacks
8141 beforeClose: null,
8142 close: null,
8143 drag: null,
8144 dragStart: null,
8145 dragStop: null,
8146 focus: null,
8147 open: null,
8148 resize: null,
8149 resizeStart: null,
8150 resizeStop: null
8151 },
8152
8153 sizeRelatedOptions: {
8154 buttons: true,
8155 height: true,
8156 maxHeight: true,
8157 maxWidth: true,
8158 minHeight: true,
8159 minWidth: true,
8160 width: true
8161 },
8162
8163 resizableRelatedOptions: {
8164 maxHeight: true,
8165 maxWidth: true,
8166 minHeight: true,
8167 minWidth: true
8168 },
8169
8170 _create: function() {
8171 this.originalCss = {
8172 display: this.element[ 0 ].style.display,
8173 width: this.element[ 0 ].style.width,
8174 minHeight: this.element[ 0 ].style.minHeight,
8175 maxHeight: this.element[ 0 ].style.maxHeight,
8176 height: this.element[ 0 ].style.height
8177 };
8178 this.originalPosition = {
8179 parent: this.element.parent(),
8180 index: this.element.parent().children().index( this.element )
8181 };
8182 this.originalTitle = this.element.attr( "title" );
8183 this.options.title = this.options.title || this.originalTitle;
8184
8185 this._createWrapper();
8186
8187 this.element
8188 .show()
8189 .removeAttr( "title" )
8190 .addClass( "ui-dialog-content ui-widget-content" )
8191 .appendTo( this.uiDialog );
8192
8193 this._createTitlebar();
8194 this._createButtonPane();
8195
8196 if ( this.options.draggable && $.fn.draggable ) {
8197 this._makeDraggable();
8198 }
8199 if ( this.options.resizable && $.fn.resizable ) {
8200 this._makeResizable();
8201 }
8202
8203 this._isOpen = false;
8204
8205 this._trackFocus();
8206 },
8207
8208 _init: function() {
8209 if ( this.options.autoOpen ) {
8210 this.open();
8211 }
8212 },
8213
8214 _appendTo: function() {
8215 var element = this.options.appendTo;
8216 if ( element && (element.jquery || element.nodeType) ) {
8217 return $( element );
8218 }
8219 return this.document.find( element || "body" ).eq( 0 );
8220 },
8221
8222 _destroy: function() {
8223 var next,
8224 originalPosition = this.originalPosition;
8225
8226 this._untrackInstance();
8227 this._destroyOverlay();
8228
8229 this.element
8230 .removeUniqueId()
8231 .removeClass( "ui-dialog-content ui-widget-content" )
8232 .css( this.originalCss )
8233 // Without detaching first, the following becomes really slow
8234 .detach();
8235
8236 this.uiDialog.stop( true, true ).remove();
8237
8238 if ( this.originalTitle ) {
8239 this.element.attr( "title", this.originalTitle );
8240 }
8241
8242 next = originalPosition.parent.children().eq( originalPosition.index );
8243 // Don't try to place the dialog next to itself (#8613)
8244 if ( next.length && next[ 0 ] !== this.element[ 0 ] ) {
8245 next.before( this.element );
8246 } else {
8247 originalPosition.parent.append( this.element );
8248 }
8249 },
8250
8251 widget: function() {
8252 return this.uiDialog;
8253 },
8254
8255 disable: $.noop,
8256 enable: $.noop,
8257
8258 close: function( event ) {
8259 var activeElement,
8260 that = this;
8261
8262 if ( !this._isOpen || this._trigger( "beforeClose", event ) === false ) {
8263 return;
8264 }
8265
8266 this._isOpen = false;
8267 this._focusedElement = null;
8268 this._destroyOverlay();
8269 this._untrackInstance();
8270
8271 if ( !this.opener.filter( ":focusable" ).focus().length ) {
8272
8273 // support: IE9
8274 // IE9 throws an "Unspecified error" accessing document.activeElement from an <iframe>
8275 try {
8276 activeElement = this.document[ 0 ].activeElement;
8277
8278 // Support: IE9, IE10
8279 // If the <body> is blurred, IE will switch windows, see #4520
8280 if ( activeElement && activeElement.nodeName.toLowerCase() !== "body" ) {
8281
8282 // Hiding a focused element doesn't trigger blur in WebKit
8283 // so in case we have nothing to focus on, explicitly blur the active element
8284 // https://bugs.webkit.org/show_bug.cgi?id=47182
8285 $( activeElement ).blur();
8286 }
8287 } catch ( error ) {}
8288 }
8289
8290 this._hide( this.uiDialog, this.options.hide, function() {
8291 that._trigger( "close", event );
8292 });
8293 },
8294
8295 isOpen: function() {
8296 return this._isOpen;
8297 },
8298
8299 moveToTop: function() {
8300 this._moveToTop();
8301 },
8302
8303 _moveToTop: function( event, silent ) {
8304 var moved = false,
8305 zIndices = this.uiDialog.siblings( ".ui-front:visible" ).map(function() {
8306 return +$( this ).css( "z-index" );
8307 }).get(),
8308 zIndexMax = Math.max.apply( null, zIndices );
8309
8310 if ( zIndexMax >= +this.uiDialog.css( "z-index" ) ) {
8311 this.uiDialog.css( "z-index", zIndexMax + 1 );
8312 moved = true;
8313 }
8314
8315 if ( moved && !silent ) {
8316 this._trigger( "focus", event );
8317 }
8318 return moved;
8319 },
8320
8321 open: function() {
8322 var that = this;
8323 if ( this._isOpen ) {
8324 if ( this._moveToTop() ) {
8325 this._focusTabbable();
8326 }
8327 return;
8328 }
8329
8330 this._isOpen = true;
8331 this.opener = $( this.document[ 0 ].activeElement );
8332
8333 this._size();
8334 this._position();
8335 this._createOverlay();
8336 this._moveToTop( null, true );
8337
8338 // Ensure the overlay is moved to the top with the dialog, but only when
8339 // opening. The overlay shouldn't move after the dialog is open so that
8340 // modeless dialogs opened after the modal dialog stack properly.
8341 if ( this.overlay ) {
8342 this.overlay.css( "z-index", this.uiDialog.css( "z-index" ) - 1 );
8343 }
8344
8345 this._show( this.uiDialog, this.options.show, function() {
8346 that._focusTabbable();
8347 that._trigger( "focus" );
8348 });
8349
8350 // Track the dialog immediately upon openening in case a focus event
8351 // somehow occurs outside of the dialog before an element inside the
8352 // dialog is focused (#10152)
8353 this._makeFocusTarget();
8354
8355 this._trigger( "open" );
8356 },
8357
8358 _focusTabbable: function() {
8359 // Set focus to the first match:
8360 // 1. An element that was focused previously
8361 // 2. First element inside the dialog matching [autofocus]
8362 // 3. Tabbable element inside the content element
8363 // 4. Tabbable element inside the buttonpane
8364 // 5. The close button
8365 // 6. The dialog itself
8366 var hasFocus = this._focusedElement;
8367 if ( !hasFocus ) {
8368 hasFocus = this.element.find( "[autofocus]" );
8369 }
8370 if ( !hasFocus.length ) {
8371 hasFocus = this.element.find( ":tabbable" );
8372 }
8373 if ( !hasFocus.length ) {
8374 hasFocus = this.uiDialogButtonPane.find( ":tabbable" );
8375 }
8376 if ( !hasFocus.length ) {
8377 hasFocus = this.uiDialogTitlebarClose.filter( ":tabbable" );
8378 }
8379 if ( !hasFocus.length ) {
8380 hasFocus = this.uiDialog;
8381 }
8382 hasFocus.eq( 0 ).focus();
8383 },
8384
8385 _keepFocus: function( event ) {
8386 function checkFocus() {
8387 var activeElement = this.document[0].activeElement,
8388 isActive = this.uiDialog[0] === activeElement ||
8389 $.contains( this.uiDialog[0], activeElement );
8390 if ( !isActive ) {
8391 this._focusTabbable();
8392 }
8393 }
8394 event.preventDefault();
8395 checkFocus.call( this );
8396 // support: IE
8397 // IE <= 8 doesn't prevent moving focus even with event.preventDefault()
8398 // so we check again later
8399 this._delay( checkFocus );
8400 },
8401
8402 _createWrapper: function() {
8403 this.uiDialog = $("<div>")
8404 .addClass( "ui-dialog ui-widget ui-widget-content ui-corner-all ui-front " +
8405 this.options.dialogClass )
8406 .hide()
8407 .attr({
8408 // Setting tabIndex makes the div focusable
8409 tabIndex: -1,
8410 role: "dialog"
8411 })
8412 .appendTo( this._appendTo() );
8413
8414 this._on( this.uiDialog, {
8415 keydown: function( event ) {
8416 if ( this.options.closeOnEscape && !event.isDefaultPrevented() && event.keyCode &&
8417 event.keyCode === $.ui.keyCode.ESCAPE ) {
8418 event.preventDefault();
8419 this.close( event );
8420 return;
8421 }
8422
8423 // prevent tabbing out of dialogs
8424 if ( event.keyCode !== $.ui.keyCode.TAB || event.isDefaultPrevented() ) {
8425 return;
8426 }
8427 var tabbables = this.uiDialog.find( ":tabbable" ),
8428 first = tabbables.filter( ":first" ),
8429 last = tabbables.filter( ":last" );
8430
8431 if ( ( event.target === last[0] || event.target === this.uiDialog[0] ) && !event.shiftKey ) {
8432 this._delay(function() {
8433 first.focus();
8434 });
8435 event.preventDefault();
8436 } else if ( ( event.target === first[0] || event.target === this.uiDialog[0] ) && event.shiftKey ) {
8437 this._delay(function() {
8438 last.focus();
8439 });
8440 event.preventDefault();
8441 }
8442 },
8443 mousedown: function( event ) {
8444 if ( this._moveToTop( event ) ) {
8445 this._focusTabbable();
8446 }
8447 }
8448 });
8449
8450 // We assume that any existing aria-describedby attribute means
8451 // that the dialog content is marked up properly
8452 // otherwise we brute force the content as the description
8453 if ( !this.element.find( "[aria-describedby]" ).length ) {
8454 this.uiDialog.attr({
8455 "aria-describedby": this.element.uniqueId().attr( "id" )
8456 });
8457 }
8458 },
8459
8460 _createTitlebar: function() {
8461 var uiDialogTitle;
8462
8463 this.uiDialogTitlebar = $( "<div>" )
8464 .addClass( "ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix" )
8465 .prependTo( this.uiDialog );
8466 this._on( this.uiDialogTitlebar, {
8467 mousedown: function( event ) {
8468 // Don't prevent click on close button (#8838)
8469 // Focusing a dialog that is partially scrolled out of view
8470 // causes the browser to scroll it into view, preventing the click event
8471 if ( !$( event.target ).closest( ".ui-dialog-titlebar-close" ) ) {
8472 // Dialog isn't getting focus when dragging (#8063)
8473 this.uiDialog.focus();
8474 }
8475 }
8476 });
8477
8478 // support: IE
8479 // Use type="button" to prevent enter keypresses in textboxes from closing the
8480 // dialog in IE (#9312)
8481 this.uiDialogTitlebarClose = $( "<button type='button'></button>" )
8482 .button({
8483 label: this.options.closeText,
8484 icons: {
8485 primary: "ui-icon-closethick"
8486 },
8487 text: false
8488 })
8489 .addClass( "ui-dialog-titlebar-close" )
8490 .appendTo( this.uiDialogTitlebar );
8491 this._on( this.uiDialogTitlebarClose, {
8492 click: function( event ) {
8493 event.preventDefault();
8494 this.close( event );
8495 }
8496 });
8497
8498 uiDialogTitle = $( "<span>" )
8499 .uniqueId()
8500 .addClass( "ui-dialog-title" )
8501 .prependTo( this.uiDialogTitlebar );
8502 this._title( uiDialogTitle );
8503
8504 this.uiDialog.attr({
8505 "aria-labelledby": uiDialogTitle.attr( "id" )
8506 });
8507 },
8508
8509 _title: function( title ) {
8510 if ( !this.options.title ) {
8511 title.html( " " );
8512 }
8513 title.text( this.options.title );
8514 },
8515
8516 _createButtonPane: function() {
8517 this.uiDialogButtonPane = $( "<div>" )
8518 .addClass( "ui-dialog-buttonpane ui-widget-content ui-helper-clearfix" );
8519
8520 this.uiButtonSet = $( "<div>" )
8521 .addClass( "ui-dialog-buttonset" )
8522 .appendTo( this.uiDialogButtonPane );
8523
8524 this._createButtons();
8525 },
8526
8527 _createButtons: function() {
8528 var that = this,
8529 buttons = this.options.buttons;
8530
8531 // if we already have a button pane, remove it
8532 this.uiDialogButtonPane.remove();
8533 this.uiButtonSet.empty();
8534
8535 if ( $.isEmptyObject( buttons ) || ($.isArray( buttons ) && !buttons.length) ) {
8536 this.uiDialog.removeClass( "ui-dialog-buttons" );
8537 return;
8538 }
8539
8540 $.each( buttons, function( name, props ) {
8541 var click, buttonOptions;
8542 props = $.isFunction( props ) ?
8543 { click: props, text: name } :
8544 props;
8545 // Default to a non-submitting button
8546 props = $.extend( { type: "button" }, props );
8547 // Change the context for the click callback to be the main element
8548 click = props.click;
8549 props.click = function() {
8550 click.apply( that.element[ 0 ], arguments );
8551 };
8552 buttonOptions = {
8553 icons: props.icons,
8554 text: props.showText
8555 };
8556 delete props.icons;
8557 delete props.showText;
8558 $( "<button></button>", props )
8559 .button( buttonOptions )
8560 .appendTo( that.uiButtonSet );
8561 });
8562 this.uiDialog.addClass( "ui-dialog-buttons" );
8563 this.uiDialogButtonPane.appendTo( this.uiDialog );
8564 },
8565
8566 _makeDraggable: function() {
8567 var that = this,
8568 options = this.options;
8569
8570 function filteredUi( ui ) {
8571 return {
8572 position: ui.position,
8573 offset: ui.offset
8574 };
8575 }
8576
8577 this.uiDialog.draggable({
8578 cancel: ".ui-dialog-content, .ui-dialog-titlebar-close",
8579 handle: ".ui-dialog-titlebar",
8580 containment: "document",
8581 start: function( event, ui ) {
8582 $( this ).addClass( "ui-dialog-dragging" );
8583 that._blockFrames();
8584 that._trigger( "dragStart", event, filteredUi( ui ) );
8585 },
8586 drag: function( event, ui ) {
8587 that._trigger( "drag", event, filteredUi( ui ) );
8588 },
8589 stop: function( event, ui ) {
8590 var left = ui.offset.left - that.document.scrollLeft(),
8591 top = ui.offset.top - that.document.scrollTop();
8592
8593 options.position = {
8594 my: "left top",
8595 at: "left" + (left >= 0 ? "+" : "") + left + " " +
8596 "top" + (top >= 0 ? "+" : "") + top,
8597 of: that.window
8598 };
8599 $( this ).removeClass( "ui-dialog-dragging" );
8600 that._unblockFrames();
8601 that._trigger( "dragStop", event, filteredUi( ui ) );
8602 }
8603 });
8604 },
8605
8606 _makeResizable: function() {
8607 var that = this,
8608 options = this.options,
8609 handles = options.resizable,
8610 // .ui-resizable has position: relative defined in the stylesheet
8611 // but dialogs have to use absolute or fixed positioning
8612 position = this.uiDialog.css("position"),
8613 resizeHandles = typeof handles === "string" ?
8614 handles :
8615 "n,e,s,w,se,sw,ne,nw";
8616
8617 function filteredUi( ui ) {
8618 return {
8619 originalPosition: ui.originalPosition,
8620 originalSize: ui.originalSize,
8621 position: ui.position,
8622 size: ui.size
8623 };
8624 }
8625
8626 this.uiDialog.resizable({
8627 cancel: ".ui-dialog-content",
8628 containment: "document",
8629 alsoResize: this.element,
8630 maxWidth: options.maxWidth,
8631 maxHeight: options.maxHeight,
8632 minWidth: options.minWidth,
8633 minHeight: this._minHeight(),
8634 handles: resizeHandles,
8635 start: function( event, ui ) {
8636 $( this ).addClass( "ui-dialog-resizing" );
8637 that._blockFrames();
8638 that._trigger( "resizeStart", event, filteredUi( ui ) );
8639 },
8640 resize: function( event, ui ) {
8641 that._trigger( "resize", event, filteredUi( ui ) );
8642 },
8643 stop: function( event, ui ) {
8644 var offset = that.uiDialog.offset(),
8645 left = offset.left - that.document.scrollLeft(),
8646 top = offset.top - that.document.scrollTop();
8647
8648 options.height = that.uiDialog.height();
8649 options.width = that.uiDialog.width();
8650 options.position = {
8651 my: "left top",
8652 at: "left" + (left >= 0 ? "+" : "") + left + " " +
8653 "top" + (top >= 0 ? "+" : "") + top,
8654 of: that.window
8655 };
8656 $( this ).removeClass( "ui-dialog-resizing" );
8657 that._unblockFrames();
8658 that._trigger( "resizeStop", event, filteredUi( ui ) );
8659 }
8660 })
8661 .css( "position", position );
8662 },
8663
8664 _trackFocus: function() {
8665 this._on( this.widget(), {
8666 focusin: function( event ) {
8667 this._makeFocusTarget();
8668 this._focusedElement = $( event.target );
8669 }
8670 });
8671 },
8672
8673 _makeFocusTarget: function() {
8674 this._untrackInstance();
8675 this._trackingInstances().unshift( this );
8676 },
8677
8678 _untrackInstance: function() {
8679 var instances = this._trackingInstances(),
8680 exists = $.inArray( this, instances );
8681 if ( exists !== -1 ) {
8682 instances.splice( exists, 1 );
8683 }
8684 },
8685
8686 _trackingInstances: function() {
8687 var instances = this.document.data( "ui-dialog-instances" );
8688 if ( !instances ) {
8689 instances = [];
8690 this.document.data( "ui-dialog-instances", instances );
8691 }
8692 return instances;
8693 },
8694
8695 _minHeight: function() {
8696 var options = this.options;
8697
8698 return options.height === "auto" ?
8699 options.minHeight :
8700 Math.min( options.minHeight, options.height );
8701 },
8702
8703 _position: function() {
8704 // Need to show the dialog to get the actual offset in the position plugin
8705 var isVisible = this.uiDialog.is( ":visible" );
8706 if ( !isVisible ) {
8707 this.uiDialog.show();
8708 }
8709 this.uiDialog.position( this.options.position );
8710 if ( !isVisible ) {
8711 this.uiDialog.hide();
8712 }
8713 },
8714
8715 _setOptions: function( options ) {
8716 var that = this,
8717 resize = false,
8718 resizableOptions = {};
8719
8720 $.each( options, function( key, value ) {
8721 that._setOption( key, value );
8722
8723 if ( key in that.sizeRelatedOptions ) {
8724 resize = true;
8725 }
8726 if ( key in that.resizableRelatedOptions ) {
8727 resizableOptions[ key ] = value;
8728 }
8729 });
8730
8731 if ( resize ) {
8732 this._size();
8733 this._position();
8734 }
8735 if ( this.uiDialog.is( ":data(ui-resizable)" ) ) {
8736 this.uiDialog.resizable( "option", resizableOptions );
8737 }
8738 },
8739
8740 _setOption: function( key, value ) {
8741 var isDraggable, isResizable,
8742 uiDialog = this.uiDialog;
8743
8744 if ( key === "dialogClass" ) {
8745 uiDialog
8746 .removeClass( this.options.dialogClass )
8747 .addClass( value );
8748 }
8749
8750 if ( key === "disabled" ) {
8751 return;
8752 }
8753
8754 this._super( key, value );
8755
8756 if ( key === "appendTo" ) {
8757 this.uiDialog.appendTo( this._appendTo() );
8758 }
8759
8760 if ( key === "buttons" ) {
8761 this._createButtons();
8762 }
8763
8764 if ( key === "closeText" ) {
8765 this.uiDialogTitlebarClose.button({
8766 // Ensure that we always pass a string
8767 label: "" + value
8768 });
8769 }
8770
8771 if ( key === "draggable" ) {
8772 isDraggable = uiDialog.is( ":data(ui-draggable)" );
8773 if ( isDraggable && !value ) {
8774 uiDialog.draggable( "destroy" );
8775 }
8776
8777 if ( !isDraggable && value ) {
8778 this._makeDraggable();
8779 }
8780 }
8781
8782 if ( key === "position" ) {
8783 this._position();
8784 }
8785
8786 if ( key === "resizable" ) {
8787 // currently resizable, becoming non-resizable
8788 isResizable = uiDialog.is( ":data(ui-resizable)" );
8789 if ( isResizable && !value ) {
8790 uiDialog.resizable( "destroy" );
8791 }
8792
8793 // currently resizable, changing handles
8794 if ( isResizable && typeof value === "string" ) {
8795 uiDialog.resizable( "option", "handles", value );
8796 }
8797
8798 // currently non-resizable, becoming resizable
8799 if ( !isResizable && value !== false ) {
8800 this._makeResizable();
8801 }
8802 }
8803
8804 if ( key === "title" ) {
8805 this._title( this.uiDialogTitlebar.find( ".ui-dialog-title" ) );
8806 }
8807 },
8808
8809 _size: function() {
8810 // If the user has resized the dialog, the .ui-dialog and .ui-dialog-content
8811 // divs will both have width and height set, so we need to reset them
8812 var nonContentHeight, minContentHeight, maxContentHeight,
8813 options = this.options;
8814
8815 // Reset content sizing
8816 this.element.show().css({
8817 width: "auto",
8818 minHeight: 0,
8819 maxHeight: "none",
8820 height: 0
8821 });
8822
8823 if ( options.minWidth > options.width ) {
8824 options.width = options.minWidth;
8825 }
8826
8827 // reset wrapper sizing
8828 // determine the height of all the non-content elements
8829 nonContentHeight = this.uiDialog.css({
8830 height: "auto",
8831 width: options.width
8832 })
8833 .outerHeight();
8834 minContentHeight = Math.max( 0, options.minHeight - nonContentHeight );
8835 maxContentHeight = typeof options.maxHeight === "number" ?
8836 Math.max( 0, options.maxHeight - nonContentHeight ) :
8837 "none";
8838
8839 if ( options.height === "auto" ) {
8840 this.element.css({
8841 minHeight: minContentHeight,
8842 maxHeight: maxContentHeight,
8843 height: "auto"
8844 });
8845 } else {
8846 this.element.height( Math.max( 0, options.height - nonContentHeight ) );
8847 }
8848
8849 if ( this.uiDialog.is( ":data(ui-resizable)" ) ) {
8850 this.uiDialog.resizable( "option", "minHeight", this._minHeight() );
8851 }
8852 },
8853
8854 _blockFrames: function() {
8855 this.iframeBlocks = this.document.find( "iframe" ).map(function() {
8856 var iframe = $( this );
8857
8858 return $( "<div>" )
8859 .css({
8860 position: "absolute",
8861 width: iframe.outerWidth(),
8862 height: iframe.outerHeight()
8863 })
8864 .appendTo( iframe.parent() )
8865 .offset( iframe.offset() )[0];
8866 });
8867 },
8868
8869 _unblockFrames: function() {
8870 if ( this.iframeBlocks ) {
8871 this.iframeBlocks.remove();
8872 delete this.iframeBlocks;
8873 }
8874 },
8875
8876 _allowInteraction: function( event ) {
8877 if ( $( event.target ).closest( ".ui-dialog" ).length ) {
8878 return true;
8879 }
8880
8881 // TODO: Remove hack when datepicker implements
8882 // the .ui-front logic (#8989)
8883 return !!$( event.target ).closest( ".ui-datepicker" ).length;
8884 },
8885
8886 _createOverlay: function() {
8887 if ( !this.options.modal ) {
8888 return;
8889 }
8890
8891 // We use a delay in case the overlay is created from an
8892 // event that we're going to be cancelling (#2804)
8893 var isOpening = true;
8894 this._delay(function() {
8895 isOpening = false;
8896 });
8897
8898 if ( !this.document.data( "ui-dialog-overlays" ) ) {
8899
8900 // Prevent use of anchors and inputs
8901 // Using _on() for an event handler shared across many instances is
8902 // safe because the dialogs stack and must be closed in reverse order
8903 this._on( this.document, {
8904 focusin: function( event ) {
8905 if ( isOpening ) {
8906 return;
8907 }
8908
8909 if ( !this._allowInteraction( event ) ) {
8910 event.preventDefault();
8911 this._trackingInstances()[ 0 ]._focusTabbable();
8912 }
8913 }
8914 });
8915 }
8916
8917 this.overlay = $( "<div>" )
8918 .addClass( "ui-widget-overlay ui-front" )
8919 .appendTo( this._appendTo() );
8920 this._on( this.overlay, {
8921 mousedown: "_keepFocus"
8922 });
8923 this.document.data( "ui-dialog-overlays",
8924 (this.document.data( "ui-dialog-overlays" ) || 0) + 1 );
8925 },
8926
8927 _destroyOverlay: function() {
8928 if ( !this.options.modal ) {
8929 return;
8930 }
8931
8932 if ( this.overlay ) {
8933 var overlays = this.document.data( "ui-dialog-overlays" ) - 1;
8934
8935 if ( !overlays ) {
8936 this.document
8937 .unbind( "focusin" )
8938 .removeData( "ui-dialog-overlays" );
8939 } else {
8940 this.document.data( "ui-dialog-overlays", overlays );
8941 }
8942
8943 this.overlay.remove();
8944 this.overlay = null;
8945 }
8946 }
8947 });
8948
8949
8950 /*!
8951 * jQuery UI Droppable 1.11.4
8952 * http://jqueryui.com
8953 *
8954 * Copyright jQuery Foundation and other contributors
8955 * Released under the MIT license.
8956 * http://jquery.org/license
8957 *
8958 * http://api.jqueryui.com/droppable/
8959 */
8960
8961
8962 $.widget( "ui.droppable", {
8963 version: "1.11.4",
8964 widgetEventPrefix: "drop",
8965 options: {
8966 accept: "*",
8967 activeClass: false,
8968 addClasses: true,
8969 greedy: false,
8970 hoverClass: false,
8971 scope: "default",
8972 tolerance: "intersect",
8973
8974 // callbacks
8975 activate: null,
8976 deactivate: null,
8977 drop: null,
8978 out: null,
8979 over: null
8980 },
8981 _create: function() {
8982
8983 var proportions,
8984 o = this.options,
8985 accept = o.accept;
8986
8987 this.isover = false;
8988 this.isout = true;
8989
8990 this.accept = $.isFunction( accept ) ? accept : function( d ) {
8991 return d.is( accept );
8992 };
8993
8994 this.proportions = function( /* valueToWrite */ ) {
8995 if ( arguments.length ) {
8996 // Store the droppable's proportions
8997 proportions = arguments[ 0 ];
8998 } else {
8999 // Retrieve or derive the droppable's proportions
9000 return proportions ?
9001 proportions :
9002 proportions = {
9003 width: this.element[ 0 ].offsetWidth,
9004 height: this.element[ 0 ].offsetHeight
9005 };
9006 }
9007 };
9008
9009 this._addToManager( o.scope );
9010
9011 o.addClasses && this.element.addClass( "ui-droppable" );
9012
9013 },
9014
9015 _addToManager: function( scope ) {
9016 // Add the reference and positions to the manager
9017 $.ui.ddmanager.droppables[ scope ] = $.ui.ddmanager.droppables[ scope ] || [];
9018 $.ui.ddmanager.droppables[ scope ].push( this );
9019 },
9020
9021 _splice: function( drop ) {
9022 var i = 0;
9023 for ( ; i < drop.length; i++ ) {
9024 if ( drop[ i ] === this ) {
9025 drop.splice( i, 1 );
9026 }
9027 }
9028 },
9029
9030 _destroy: function() {
9031 var drop = $.ui.ddmanager.droppables[ this.options.scope ];
9032
9033 this._splice( drop );
9034
9035 this.element.removeClass( "ui-droppable ui-droppable-disabled" );
9036 },
9037
9038 _setOption: function( key, value ) {
9039
9040 if ( key === "accept" ) {
9041 this.accept = $.isFunction( value ) ? value : function( d ) {
9042 return d.is( value );
9043 };
9044 } else if ( key === "scope" ) {
9045 var drop = $.ui.ddmanager.droppables[ this.options.scope ];
9046
9047 this._splice( drop );
9048 this._addToManager( value );
9049 }
9050
9051 this._super( key, value );
9052 },
9053
9054 _activate: function( event ) {
9055 var draggable = $.ui.ddmanager.current;
9056 if ( this.options.activeClass ) {
9057 this.element.addClass( this.options.activeClass );
9058 }
9059 if ( draggable ){
9060 this._trigger( "activate", event, this.ui( draggable ) );
9061 }
9062 },
9063
9064 _deactivate: function( event ) {
9065 var draggable = $.ui.ddmanager.current;
9066 if ( this.options.activeClass ) {
9067 this.element.removeClass( this.options.activeClass );
9068 }
9069 if ( draggable ){
9070 this._trigger( "deactivate", event, this.ui( draggable ) );
9071 }
9072 },
9073
9074 _over: function( event ) {
9075
9076 var draggable = $.ui.ddmanager.current;
9077
9078 // Bail if draggable and droppable are same element
9079 if ( !draggable || ( draggable.currentItem || draggable.element )[ 0 ] === this.element[ 0 ] ) {
9080 return;
9081 }
9082
9083 if ( this.accept.call( this.element[ 0 ], ( draggable.currentItem || draggable.element ) ) ) {
9084 if ( this.options.hoverClass ) {
9085 this.element.addClass( this.options.hoverClass );
9086 }
9087 this._trigger( "over", event, this.ui( draggable ) );
9088 }
9089
9090 },
9091
9092 _out: function( event ) {
9093
9094 var draggable = $.ui.ddmanager.current;
9095
9096 // Bail if draggable and droppable are same element
9097 if ( !draggable || ( draggable.currentItem || draggable.element )[ 0 ] === this.element[ 0 ] ) {
9098 return;
9099 }
9100
9101 if ( this.accept.call( this.element[ 0 ], ( draggable.currentItem || draggable.element ) ) ) {
9102 if ( this.options.hoverClass ) {
9103 this.element.removeClass( this.options.hoverClass );
9104 }
9105 this._trigger( "out", event, this.ui( draggable ) );
9106 }
9107
9108 },
9109
9110 _drop: function( event, custom ) {
9111
9112 var draggable = custom || $.ui.ddmanager.current,
9113 childrenIntersection = false;
9114
9115 // Bail if draggable and droppable are same element
9116 if ( !draggable || ( draggable.currentItem || draggable.element )[ 0 ] === this.element[ 0 ] ) {
9117 return false;
9118 }
9119
9120 this.element.find( ":data(ui-droppable)" ).not( ".ui-draggable-dragging" ).each(function() {
9121 var inst = $( this ).droppable( "instance" );
9122 if (
9123 inst.options.greedy &&
9124 !inst.options.disabled &&
9125 inst.options.scope === draggable.options.scope &&
9126 inst.accept.call( inst.element[ 0 ], ( draggable.currentItem || draggable.element ) ) &&
9127 $.ui.intersect( draggable, $.extend( inst, { offset: inst.element.offset() } ), inst.options.tolerance, event )
9128 ) { childrenIntersection = true; return false; }
9129 });
9130 if ( childrenIntersection ) {
9131 return false;
9132 }
9133
9134 if ( this.accept.call( this.element[ 0 ], ( draggable.currentItem || draggable.element ) ) ) {
9135 if ( this.options.activeClass ) {
9136 this.element.removeClass( this.options.activeClass );
9137 }
9138 if ( this.options.hoverClass ) {
9139 this.element.removeClass( this.options.hoverClass );
9140 }
9141 this._trigger( "drop", event, this.ui( draggable ) );
9142 return this.element;
9143 }
9144
9145 return false;
9146
9147 },
9148
9149 ui: function( c ) {
9150 return {
9151 draggable: ( c.currentItem || c.element ),
9152 helper: c.helper,
9153 position: c.position,
9154 offset: c.positionAbs
9155 };
9156 }
9157
9158 });
9159
9160 $.ui.intersect = (function() {
9161 function isOverAxis( x, reference, size ) {
9162 return ( x >= reference ) && ( x < ( reference + size ) );
9163 }
9164
9165 return function( draggable, droppable, toleranceMode, event ) {
9166
9167 if ( !droppable.offset ) {
9168 return false;
9169 }
9170
9171 var x1 = ( draggable.positionAbs || draggable.position.absolute ).left + draggable.margins.left,
9172 y1 = ( draggable.positionAbs || draggable.position.absolute ).top + draggable.margins.top,
9173 x2 = x1 + draggable.helperProportions.width,
9174 y2 = y1 + draggable.helperProportions.height,
9175 l = droppable.offset.left,
9176 t = droppable.offset.top,
9177 r = l + droppable.proportions().width,
9178 b = t + droppable.proportions().height;
9179
9180 switch ( toleranceMode ) {
9181 case "fit":
9182 return ( l <= x1 && x2 <= r && t <= y1 && y2 <= b );
9183 case "intersect":
9184 return ( l < x1 + ( draggable.helperProportions.width / 2 ) && // Right Half
9185 x2 - ( draggable.helperProportions.width / 2 ) < r && // Left Half
9186 t < y1 + ( draggable.helperProportions.height / 2 ) && // Bottom Half
9187 y2 - ( draggable.helperProportions.height / 2 ) < b ); // Top Half
9188 case "pointer":
9189 return isOverAxis( event.pageY, t, droppable.proportions().height ) && isOverAxis( event.pageX, l, droppable.proportions().width );
9190 case "touch":
9191 return (
9192 ( y1 >= t && y1 <= b ) || // Top edge touching
9193 ( y2 >= t && y2 <= b ) || // Bottom edge touching
9194 ( y1 < t && y2 > b ) // Surrounded vertically
9195 ) && (
9196 ( x1 >= l && x1 <= r ) || // Left edge touching
9197 ( x2 >= l && x2 <= r ) || // Right edge touching
9198 ( x1 < l && x2 > r ) // Surrounded horizontally
9199 );
9200 default:
9201 return false;
9202 }
9203 };
9204 })();
9205
9206 /*
9207 This manager tracks offsets of draggables and droppables
9208 */
9209 $.ui.ddmanager = {
9210 current: null,
9211 droppables: { "default": [] },
9212 prepareOffsets: function( t, event ) {
9213
9214 var i, j,
9215 m = $.ui.ddmanager.droppables[ t.options.scope ] || [],
9216 type = event ? event.type : null, // workaround for #2317
9217 list = ( t.currentItem || t.element ).find( ":data(ui-droppable)" ).addBack();
9218
9219 droppablesLoop: for ( i = 0; i < m.length; i++ ) {
9220
9221 // No disabled and non-accepted
9222 if ( m[ i ].options.disabled || ( t && !m[ i ].accept.call( m[ i ].element[ 0 ], ( t.currentItem || t.element ) ) ) ) {
9223 continue;
9224 }
9225
9226 // Filter out elements in the current dragged item
9227 for ( j = 0; j < list.length; j++ ) {
9228 if ( list[ j ] === m[ i ].element[ 0 ] ) {
9229 m[ i ].proportions().height = 0;
9230 continue droppablesLoop;
9231 }
9232 }
9233
9234 m[ i ].visible = m[ i ].element.css( "display" ) !== "none";
9235 if ( !m[ i ].visible ) {
9236 continue;
9237 }
9238
9239 // Activate the droppable if used directly from draggables
9240 if ( type === "mousedown" ) {
9241 m[ i ]._activate.call( m[ i ], event );
9242 }
9243
9244 m[ i ].offset = m[ i ].element.offset();
9245 m[ i ].proportions({ width: m[ i ].element[ 0 ].offsetWidth, height: m[ i ].element[ 0 ].offsetHeight });
9246
9247 }
9248
9249 },
9250 drop: function( draggable, event ) {
9251
9252 var dropped = false;
9253 // Create a copy of the droppables in case the list changes during the drop (#9116)
9254 $.each( ( $.ui.ddmanager.droppables[ draggable.options.scope ] || [] ).slice(), function() {
9255
9256 if ( !this.options ) {
9257 return;
9258 }
9259 if ( !this.options.disabled && this.visible && $.ui.intersect( draggable, this, this.options.tolerance, event ) ) {
9260 dropped = this._drop.call( this, event ) || dropped;
9261 }
9262
9263 if ( !this.options.disabled && this.visible && this.accept.call( this.element[ 0 ], ( draggable.currentItem || draggable.element ) ) ) {
9264 this.isout = true;
9265 this.isover = false;
9266 this._deactivate.call( this, event );
9267 }
9268
9269 });
9270 return dropped;
9271
9272 },
9273 dragStart: function( draggable, event ) {
9274 // Listen for scrolling so that if the dragging causes scrolling the position of the droppables can be recalculated (see #5003)
9275 draggable.element.parentsUntil( "body" ).bind( "scroll.droppable", function() {
9276 if ( !draggable.options.refreshPositions ) {
9277 $.ui.ddmanager.prepareOffsets( draggable, event );
9278 }
9279 });
9280 },
9281 drag: function( draggable, event ) {
9282
9283 // If you have a highly dynamic page, you might try this option. It renders positions every time you move the mouse.
9284 if ( draggable.options.refreshPositions ) {
9285 $.ui.ddmanager.prepareOffsets( draggable, event );
9286 }
9287
9288 // Run through all droppables and check their positions based on specific tolerance options
9289 $.each( $.ui.ddmanager.droppables[ draggable.options.scope ] || [], function() {
9290
9291 if ( this.options.disabled || this.greedyChild || !this.visible ) {
9292 return;
9293 }
9294
9295 var parentInstance, scope, parent,
9296 intersects = $.ui.intersect( draggable, this, this.options.tolerance, event ),
9297 c = !intersects && this.isover ? "isout" : ( intersects && !this.isover ? "isover" : null );
9298 if ( !c ) {
9299 return;
9300 }
9301
9302 if ( this.options.greedy ) {
9303 // find droppable parents with same scope
9304 scope = this.options.scope;
9305 parent = this.element.parents( ":data(ui-droppable)" ).filter(function() {
9306 return $( this ).droppable( "instance" ).options.scope === scope;
9307 });
9308
9309 if ( parent.length ) {
9310 parentInstance = $( parent[ 0 ] ).droppable( "instance" );
9311 parentInstance.greedyChild = ( c === "isover" );
9312 }
9313 }
9314
9315 // we just moved into a greedy child
9316 if ( parentInstance && c === "isover" ) {
9317 parentInstance.isover = false;
9318 parentInstance.isout = true;
9319 parentInstance._out.call( parentInstance, event );
9320 }
9321
9322 this[ c ] = true;
9323 this[c === "isout" ? "isover" : "isout"] = false;
9324 this[c === "isover" ? "_over" : "_out"].call( this, event );
9325
9326 // we just moved out of a greedy child
9327 if ( parentInstance && c === "isout" ) {
9328 parentInstance.isout = false;
9329 parentInstance.isover = true;
9330 parentInstance._over.call( parentInstance, event );
9331 }
9332 });
9333
9334 },
9335 dragStop: function( draggable, event ) {
9336 draggable.element.parentsUntil( "body" ).unbind( "scroll.droppable" );
9337 // Call prepareOffsets one final time since IE does not fire return scroll events when overflow was caused by drag (see #5003)
9338 if ( !draggable.options.refreshPositions ) {
9339 $.ui.ddmanager.prepareOffsets( draggable, event );
9340 }
9341 }
9342 };
9343
9344 var droppable = $.ui.droppable;
9345
9346
9347 /*!
9348 * jQuery UI Effects 1.11.4
9349 * http://jqueryui.com
9350 *
9351 * Copyright jQuery Foundation and other contributors
9352 * Released under the MIT license.
9353 * http://jquery.org/license
9354 *
9355 * http://api.jqueryui.com/category/effects-core/
9356 */
9357
9358
9359 var dataSpace = "ui-effects-",
9360
9361 // Create a local jQuery because jQuery Color relies on it and the
9362 // global may not exist with AMD and a custom build (#10199)
9363 jQuery = $;
9364
9365 $.effects = {
9366 effect: {}
9367 };
9368
9369 /*!
9370 * jQuery Color Animations v2.1.2
9371 * https://github.com/jquery/jquery-color
9372 *
9373 * Copyright 2014 jQuery Foundation and other contributors
9374 * Released under the MIT license.
9375 * http://jquery.org/license
9376 *
9377 * Date: Wed Jan 16 08:47:09 2013 -0600
9378 */
9379 (function( jQuery, undefined ) {
9380
9381 var stepHooks = "backgroundColor borderBottomColor borderLeftColor borderRightColor borderTopColor color columnRuleColor outlineColor textDecorationColor textEmphasisColor",
9382
9383 // plusequals test for += 100 -= 100
9384 rplusequals = /^([\-+])=\s*(\d+\.?\d*)/,
9385 // a set of RE's that can match strings and generate color tuples.
9386 stringParsers = [ {
9387 re: /rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
9388 parse: function( execResult ) {
9389 return [
9390 execResult[ 1 ],
9391 execResult[ 2 ],
9392 execResult[ 3 ],
9393 execResult[ 4 ]
9394 ];
9395 }
9396 }, {
9397 re: /rgba?\(\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
9398 parse: function( execResult ) {
9399 return [
9400 execResult[ 1 ] * 2.55,
9401 execResult[ 2 ] * 2.55,
9402 execResult[ 3 ] * 2.55,
9403 execResult[ 4 ]
9404 ];
9405 }
9406 }, {
9407 // this regex ignores A-F because it's compared against an already lowercased string
9408 re: /#([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})/,
9409 parse: function( execResult ) {
9410 return [
9411 parseInt( execResult[ 1 ], 16 ),
9412 parseInt( execResult[ 2 ], 16 ),
9413 parseInt( execResult[ 3 ], 16 )
9414 ];
9415 }
9416 }, {
9417 // this regex ignores A-F because it's compared against an already lowercased string
9418 re: /#([a-f0-9])([a-f0-9])([a-f0-9])/,
9419 parse: function( execResult ) {
9420 return [
9421 parseInt( execResult[ 1 ] + execResult[ 1 ], 16 ),
9422 parseInt( execResult[ 2 ] + execResult[ 2 ], 16 ),
9423 parseInt( execResult[ 3 ] + execResult[ 3 ], 16 )
9424 ];
9425 }
9426 }, {
9427 re: /hsla?\(\s*(\d+(?:\.\d+)?)\s*,\s*(\d+(?:\.\d+)?)\%\s*,\s*(\d+(?:\.\d+)?)\%\s*(?:,\s*(\d?(?:\.\d+)?)\s*)?\)/,
9428 space: "hsla",
9429 parse: function( execResult ) {
9430 return [
9431 execResult[ 1 ],
9432 execResult[ 2 ] / 100,
9433 execResult[ 3 ] / 100,
9434 execResult[ 4 ]
9435 ];
9436 }
9437 } ],
9438
9439 // jQuery.Color( )
9440 color = jQuery.Color = function( color, green, blue, alpha ) {
9441 return new jQuery.Color.fn.parse( color, green, blue, alpha );
9442 },
9443 spaces = {
9444 rgba: {
9445 props: {
9446 red: {
9447 idx: 0,
9448 type: "byte"
9449 },
9450 green: {
9451 idx: 1,
9452 type: "byte"
9453 },
9454 blue: {
9455 idx: 2,
9456 type: "byte"
9457 }
9458 }
9459 },
9460
9461 hsla: {
9462 props: {
9463 hue: {
9464 idx: 0,
9465 type: "degrees"
9466 },
9467 saturation: {
9468 idx: 1,
9469 type: "percent"
9470 },
9471 lightness: {
9472 idx: 2,
9473 type: "percent"
9474 }
9475 }
9476 }
9477 },
9478 propTypes = {
9479 "byte": {
9480 floor: true,
9481 max: 255
9482 },
9483 "percent": {
9484 max: 1
9485 },
9486 "degrees": {
9487 mod: 360,
9488 floor: true
9489 }
9490 },
9491 support = color.support = {},
9492
9493 // element for support tests
9494 supportElem = jQuery( "<p>" )[ 0 ],
9495
9496 // colors = jQuery.Color.names
9497 colors,
9498
9499 // local aliases of functions called often
9500 each = jQuery.each;
9501
9502 // determine rgba support immediately
9503 supportElem.style.cssText = "background-color:rgba(1,1,1,.5)";
9504 support.rgba = supportElem.style.backgroundColor.indexOf( "rgba" ) > -1;
9505
9506 // define cache name and alpha properties
9507 // for rgba and hsla spaces
9508 each( spaces, function( spaceName, space ) {
9509 space.cache = "_" + spaceName;
9510 space.props.alpha = {
9511 idx: 3,
9512 type: "percent",
9513 def: 1
9514 };
9515 });
9516
9517 function clamp( value, prop, allowEmpty ) {
9518 var type = propTypes[ prop.type ] || {};
9519
9520 if ( value == null ) {
9521 return (allowEmpty || !prop.def) ? null : prop.def;
9522 }
9523
9524 // ~~ is an short way of doing floor for positive numbers
9525 value = type.floor ? ~~value : parseFloat( value );
9526
9527 // IE will pass in empty strings as value for alpha,
9528 // which will hit this case
9529 if ( isNaN( value ) ) {
9530 return prop.def;
9531 }
9532
9533 if ( type.mod ) {
9534 // we add mod before modding to make sure that negatives values
9535 // get converted properly: -10 -> 350
9536 return (value + type.mod) % type.mod;
9537 }
9538
9539 // for now all property types without mod have min and max
9540 return 0 > value ? 0 : type.max < value ? type.max : value;
9541 }
9542
9543 function stringParse( string ) {
9544 var inst = color(),
9545 rgba = inst._rgba = [];
9546
9547 string = string.toLowerCase();
9548
9549 each( stringParsers, function( i, parser ) {
9550 var parsed,
9551 match = parser.re.exec( string ),
9552 values = match && parser.parse( match ),
9553 spaceName = parser.space || "rgba";
9554
9555 if ( values ) {
9556 parsed = inst[ spaceName ]( values );
9557
9558 // if this was an rgba parse the assignment might happen twice
9559 // oh well....
9560 inst[ spaces[ spaceName ].cache ] = parsed[ spaces[ spaceName ].cache ];
9561 rgba = inst._rgba = parsed._rgba;
9562
9563 // exit each( stringParsers ) here because we matched
9564 return false;
9565 }
9566 });
9567
9568 // Found a stringParser that handled it
9569 if ( rgba.length ) {
9570
9571 // if this came from a parsed string, force "transparent" when alpha is 0
9572 // chrome, (and maybe others) return "transparent" as rgba(0,0,0,0)
9573 if ( rgba.join() === "0,0,0,0" ) {
9574 jQuery.extend( rgba, colors.transparent );
9575 }
9576 return inst;
9577 }
9578
9579 // named colors
9580 return colors[ string ];
9581 }
9582
9583 color.fn = jQuery.extend( color.prototype, {
9584 parse: function( red, green, blue, alpha ) {
9585 if ( red === undefined ) {
9586 this._rgba = [ null, null, null, null ];
9587 return this;
9588 }
9589 if ( red.jquery || red.nodeType ) {
9590 red = jQuery( red ).css( green );
9591 green = undefined;
9592 }
9593
9594 var inst = this,
9595 type = jQuery.type( red ),
9596 rgba = this._rgba = [];
9597
9598 // more than 1 argument specified - assume ( red, green, blue, alpha )
9599 if ( green !== undefined ) {
9600 red = [ red, green, blue, alpha ];
9601 type = "array";
9602 }
9603
9604 if ( type === "string" ) {
9605 return this.parse( stringParse( red ) || colors._default );
9606 }
9607
9608 if ( type === "array" ) {
9609 each( spaces.rgba.props, function( key, prop ) {
9610 rgba[ prop.idx ] = clamp( red[ prop.idx ], prop );
9611 });
9612 return this;
9613 }
9614
9615 if ( type === "object" ) {
9616 if ( red instanceof color ) {
9617 each( spaces, function( spaceName, space ) {
9618 if ( red[ space.cache ] ) {
9619 inst[ space.cache ] = red[ space.cache ].slice();
9620 }
9621 });
9622 } else {
9623 each( spaces, function( spaceName, space ) {
9624 var cache = space.cache;
9625 each( space.props, function( key, prop ) {
9626
9627 // if the cache doesn't exist, and we know how to convert
9628 if ( !inst[ cache ] && space.to ) {
9629
9630 // if the value was null, we don't need to copy it
9631 // if the key was alpha, we don't need to copy it either
9632 if ( key === "alpha" || red[ key ] == null ) {
9633 return;
9634 }
9635 inst[ cache ] = space.to( inst._rgba );
9636 }
9637
9638 // this is the only case where we allow nulls for ALL properties.
9639 // call clamp with alwaysAllowEmpty
9640 inst[ cache ][ prop.idx ] = clamp( red[ key ], prop, true );
9641 });
9642
9643 // everything defined but alpha?
9644 if ( inst[ cache ] && jQuery.inArray( null, inst[ cache ].slice( 0, 3 ) ) < 0 ) {
9645 // use the default of 1
9646 inst[ cache ][ 3 ] = 1;
9647 if ( space.from ) {
9648 inst._rgba = space.from( inst[ cache ] );
9649 }
9650 }
9651 });
9652 }
9653 return this;
9654 }
9655 },
9656 is: function( compare ) {
9657 var is = color( compare ),
9658 same = true,
9659 inst = this;
9660
9661 each( spaces, function( _, space ) {
9662 var localCache,
9663 isCache = is[ space.cache ];
9664 if (isCache) {
9665 localCache = inst[ space.cache ] || space.to && space.to( inst._rgba ) || [];
9666 each( space.props, function( _, prop ) {
9667 if ( isCache[ prop.idx ] != null ) {
9668 same = ( isCache[ prop.idx ] === localCache[ prop.idx ] );
9669 return same;
9670 }
9671 });
9672 }
9673 return same;
9674 });
9675 return same;
9676 },
9677 _space: function() {
9678 var used = [],
9679 inst = this;
9680 each( spaces, function( spaceName, space ) {
9681 if ( inst[ space.cache ] ) {
9682 used.push( spaceName );
9683 }
9684 });
9685 return used.pop();
9686 },
9687 transition: function( other, distance ) {
9688 var end = color( other ),
9689 spaceName = end._space(),
9690 space = spaces[ spaceName ],
9691 startColor = this.alpha() === 0 ? color( "transparent" ) : this,
9692 start = startColor[ space.cache ] || space.to( startColor._rgba ),
9693 result = start.slice();
9694
9695 end = end[ space.cache ];
9696 each( space.props, function( key, prop ) {
9697 var index = prop.idx,
9698 startValue = start[ index ],
9699 endValue = end[ index ],
9700 type = propTypes[ prop.type ] || {};
9701
9702 // if null, don't override start value
9703 if ( endValue === null ) {
9704 return;
9705 }
9706 // if null - use end
9707 if ( startValue === null ) {
9708 result[ index ] = endValue;
9709 } else {
9710 if ( type.mod ) {
9711 if ( endValue - startValue > type.mod / 2 ) {
9712 startValue += type.mod;
9713 } else if ( startValue - endValue > type.mod / 2 ) {
9714 startValue -= type.mod;
9715 }
9716 }
9717 result[ index ] = clamp( ( endValue - startValue ) * distance + startValue, prop );
9718 }
9719 });
9720 return this[ spaceName ]( result );
9721 },
9722 blend: function( opaque ) {
9723 // if we are already opaque - return ourself
9724 if ( this._rgba[ 3 ] === 1 ) {
9725 return this;
9726 }
9727
9728 var rgb = this._rgba.slice(),
9729 a = rgb.pop(),
9730 blend = color( opaque )._rgba;
9731
9732 return color( jQuery.map( rgb, function( v, i ) {
9733 return ( 1 - a ) * blend[ i ] + a * v;
9734 }));
9735 },
9736 toRgbaString: function() {
9737 var prefix = "rgba(",
9738 rgba = jQuery.map( this._rgba, function( v, i ) {
9739 return v == null ? ( i > 2 ? 1 : 0 ) : v;
9740 });
9741
9742 if ( rgba[ 3 ] === 1 ) {
9743 rgba.pop();
9744 prefix = "rgb(";
9745 }
9746
9747 return prefix + rgba.join() + ")";
9748 },
9749 toHslaString: function() {
9750 var prefix = "hsla(",
9751 hsla = jQuery.map( this.hsla(), function( v, i ) {
9752 if ( v == null ) {
9753 v = i > 2 ? 1 : 0;
9754 }
9755
9756 // catch 1 and 2
9757 if ( i && i < 3 ) {
9758 v = Math.round( v * 100 ) + "%";
9759 }
9760 return v;
9761 });
9762
9763 if ( hsla[ 3 ] === 1 ) {
9764 hsla.pop();
9765 prefix = "hsl(";
9766 }
9767 return prefix + hsla.join() + ")";
9768 },
9769 toHexString: function( includeAlpha ) {
9770 var rgba = this._rgba.slice(),
9771 alpha = rgba.pop();
9772
9773 if ( includeAlpha ) {
9774 rgba.push( ~~( alpha * 255 ) );
9775 }
9776
9777 return "#" + jQuery.map( rgba, function( v ) {
9778
9779 // default to 0 when nulls exist
9780 v = ( v || 0 ).toString( 16 );
9781 return v.length === 1 ? "0" + v : v;
9782 }).join("");
9783 },
9784 toString: function() {
9785 return this._rgba[ 3 ] === 0 ? "transparent" : this.toRgbaString();
9786 }
9787 });
9788 color.fn.parse.prototype = color.fn;
9789
9790 // hsla conversions adapted from:
9791 // https://code.google.com/p/maashaack/source/browse/packages/graphics/trunk/src/graphics/colors/HUE2RGB.as?r=5021
9792
9793 function hue2rgb( p, q, h ) {
9794 h = ( h + 1 ) % 1;
9795 if ( h * 6 < 1 ) {
9796 return p + ( q - p ) * h * 6;
9797 }
9798 if ( h * 2 < 1) {
9799 return q;
9800 }
9801 if ( h * 3 < 2 ) {
9802 return p + ( q - p ) * ( ( 2 / 3 ) - h ) * 6;
9803 }
9804 return p;
9805 }
9806
9807 spaces.hsla.to = function( rgba ) {
9808 if ( rgba[ 0 ] == null || rgba[ 1 ] == null || rgba[ 2 ] == null ) {
9809 return [ null, null, null, rgba[ 3 ] ];
9810 }
9811 var r = rgba[ 0 ] / 255,
9812 g = rgba[ 1 ] / 255,
9813 b = rgba[ 2 ] / 255,
9814 a = rgba[ 3 ],
9815 max = Math.max( r, g, b ),
9816 min = Math.min( r, g, b ),
9817 diff = max - min,
9818 add = max + min,
9819 l = add * 0.5,
9820 h, s;
9821
9822 if ( min === max ) {
9823 h = 0;
9824 } else if ( r === max ) {
9825 h = ( 60 * ( g - b ) / diff ) + 360;
9826 } else if ( g === max ) {
9827 h = ( 60 * ( b - r ) / diff ) + 120;
9828 } else {
9829 h = ( 60 * ( r - g ) / diff ) + 240;
9830 }
9831
9832 // chroma (diff) == 0 means greyscale which, by definition, saturation = 0%
9833 // otherwise, saturation is based on the ratio of chroma (diff) to lightness (add)
9834 if ( diff === 0 ) {
9835 s = 0;
9836 } else if ( l <= 0.5 ) {
9837 s = diff / add;
9838 } else {
9839 s = diff / ( 2 - add );
9840 }
9841 return [ Math.round(h) % 360, s, l, a == null ? 1 : a ];
9842 };
9843
9844 spaces.hsla.from = function( hsla ) {
9845 if ( hsla[ 0 ] == null || hsla[ 1 ] == null || hsla[ 2 ] == null ) {
9846 return [ null, null, null, hsla[ 3 ] ];
9847 }
9848 var h = hsla[ 0 ] / 360,
9849 s = hsla[ 1 ],
9850 l = hsla[ 2 ],
9851 a = hsla[ 3 ],
9852 q = l <= 0.5 ? l * ( 1 + s ) : l + s - l * s,
9853 p = 2 * l - q;
9854
9855 return [
9856 Math.round( hue2rgb( p, q, h + ( 1 / 3 ) ) * 255 ),
9857 Math.round( hue2rgb( p, q, h ) * 255 ),
9858 Math.round( hue2rgb( p, q, h - ( 1 / 3 ) ) * 255 ),
9859 a
9860 ];
9861 };
9862
9863 each( spaces, function( spaceName, space ) {
9864 var props = space.props,
9865 cache = space.cache,
9866 to = space.to,
9867 from = space.from;
9868
9869 // makes rgba() and hsla()
9870 color.fn[ spaceName ] = function( value ) {
9871
9872 // generate a cache for this space if it doesn't exist
9873 if ( to && !this[ cache ] ) {
9874 this[ cache ] = to( this._rgba );
9875 }
9876 if ( value === undefined ) {
9877 return this[ cache ].slice();
9878 }
9879
9880 var ret,
9881 type = jQuery.type( value ),
9882 arr = ( type === "array" || type === "object" ) ? value : arguments,
9883 local = this[ cache ].slice();
9884
9885 each( props, function( key, prop ) {
9886 var val = arr[ type === "object" ? key : prop.idx ];
9887 if ( val == null ) {
9888 val = local[ prop.idx ];
9889 }
9890 local[ prop.idx ] = clamp( val, prop );
9891 });
9892
9893 if ( from ) {
9894 ret = color( from( local ) );
9895 ret[ cache ] = local;
9896 return ret;
9897 } else {
9898 return color( local );
9899 }
9900 };
9901
9902 // makes red() green() blue() alpha() hue() saturation() lightness()
9903 each( props, function( key, prop ) {
9904 // alpha is included in more than one space
9905 if ( color.fn[ key ] ) {
9906 return;
9907 }
9908 color.fn[ key ] = function( value ) {
9909 var vtype = jQuery.type( value ),
9910 fn = ( key === "alpha" ? ( this._hsla ? "hsla" : "rgba" ) : spaceName ),
9911 local = this[ fn ](),
9912 cur = local[ prop.idx ],
9913 match;
9914
9915 if ( vtype === "undefined" ) {
9916 return cur;
9917 }
9918
9919 if ( vtype === "function" ) {
9920 value = value.call( this, cur );
9921 vtype = jQuery.type( value );
9922 }
9923 if ( value == null && prop.empty ) {
9924 return this;
9925 }
9926 if ( vtype === "string" ) {
9927 match = rplusequals.exec( value );
9928 if ( match ) {
9929 value = cur + parseFloat( match[ 2 ] ) * ( match[ 1 ] === "+" ? 1 : -1 );
9930 }
9931 }
9932 local[ prop.idx ] = value;
9933 return this[ fn ]( local );
9934 };
9935 });
9936 });
9937
9938 // add cssHook and .fx.step function for each named hook.
9939 // accept a space separated string of properties
9940 color.hook = function( hook ) {
9941 var hooks = hook.split( " " );
9942 each( hooks, function( i, hook ) {
9943 jQuery.cssHooks[ hook ] = {
9944 set: function( elem, value ) {
9945 var parsed, curElem,
9946 backgroundColor = "";
9947
9948 if ( value !== "transparent" && ( jQuery.type( value ) !== "string" || ( parsed = stringParse( value ) ) ) ) {
9949 value = color( parsed || value );
9950 if ( !support.rgba && value._rgba[ 3 ] !== 1 ) {
9951 curElem = hook === "backgroundColor" ? elem.parentNode : elem;
9952 while (
9953 (backgroundColor === "" || backgroundColor === "transparent") &&
9954 curElem && curElem.style
9955 ) {
9956 try {
9957 backgroundColor = jQuery.css( curElem, "backgroundColor" );
9958 curElem = curElem.parentNode;
9959 } catch ( e ) {
9960 }
9961 }
9962
9963 value = value.blend( backgroundColor && backgroundColor !== "transparent" ?
9964 backgroundColor :
9965 "_default" );
9966 }
9967
9968 value = value.toRgbaString();
9969 }
9970 try {
9971 elem.style[ hook ] = value;
9972 } catch ( e ) {
9973 // wrapped to prevent IE from throwing errors on "invalid" values like 'auto' or 'inherit'
9974 }
9975 }
9976 };
9977 jQuery.fx.step[ hook ] = function( fx ) {
9978 if ( !fx.colorInit ) {
9979 fx.start = color( fx.elem, hook );
9980 fx.end = color( fx.end );
9981 fx.colorInit = true;
9982 }
9983 jQuery.cssHooks[ hook ].set( fx.elem, fx.start.transition( fx.end, fx.pos ) );
9984 };
9985 });
9986
9987 };
9988
9989 color.hook( stepHooks );
9990
9991 jQuery.cssHooks.borderColor = {
9992 expand: function( value ) {
9993 var expanded = {};
9994
9995 each( [ "Top", "Right", "Bottom", "Left" ], function( i, part ) {
9996 expanded[ "border" + part + "Color" ] = value;
9997 });
9998 return expanded;
9999 }
10000 };
10001
10002 // Basic color names only.
10003 // Usage of any of the other color names requires adding yourself or including
10004 // jquery.color.svg-names.js.
10005 colors = jQuery.Color.names = {
10006 // 4.1. Basic color keywords
10007 aqua: "#00ffff",
10008 black: "#000000",
10009 blue: "#0000ff",
10010 fuchsia: "#ff00ff",
10011 gray: "#808080",
10012 green: "#008000",
10013 lime: "#00ff00",
10014 maroon: "#800000",
10015 navy: "#000080",
10016 olive: "#808000",
10017 purple: "#800080",
10018 red: "#ff0000",
10019 silver: "#c0c0c0",
10020 teal: "#008080",
10021 white: "#ffffff",
10022 yellow: "#ffff00",
10023
10024 // 4.2.3. "transparent" color keyword
10025 transparent: [ null, null, null, 0 ],
10026
10027 _default: "#ffffff"
10028 };
10029
10030 })( jQuery );
10031
10032 /******************************************************************************/
10033 /****************************** CLASS ANIMATIONS ******************************/
10034 /******************************************************************************/
10035 (function() {
10036
10037 var classAnimationActions = [ "add", "remove", "toggle" ],
10038 shorthandStyles = {
10039 border: 1,
10040 borderBottom: 1,
10041 borderColor: 1,
10042 borderLeft: 1,
10043 borderRight: 1,
10044 borderTop: 1,
10045 borderWidth: 1,
10046 margin: 1,
10047 padding: 1
10048 };
10049
10050 $.each([ "borderLeftStyle", "borderRightStyle", "borderBottomStyle", "borderTopStyle" ], function( _, prop ) {
10051 $.fx.step[ prop ] = function( fx ) {
10052 if ( fx.end !== "none" && !fx.setAttr || fx.pos === 1 && !fx.setAttr ) {
10053 jQuery.style( fx.elem, prop, fx.end );
10054 fx.setAttr = true;
10055 }
10056 };
10057 });
10058
10059 function getElementStyles( elem ) {
10060 var key, len,
10061 style = elem.ownerDocument.defaultView ?
10062 elem.ownerDocument.defaultView.getComputedStyle( elem, null ) :
10063 elem.currentStyle,
10064 styles = {};
10065
10066 if ( style && style.length && style[ 0 ] && style[ style[ 0 ] ] ) {
10067 len = style.length;
10068 while ( len-- ) {
10069 key = style[ len ];
10070 if ( typeof style[ key ] === "string" ) {
10071 styles[ $.camelCase( key ) ] = style[ key ];
10072 }
10073 }
10074 // support: Opera, IE <9
10075 } else {
10076 for ( key in style ) {
10077 if ( typeof style[ key ] === "string" ) {
10078 styles[ key ] = style[ key ];
10079 }
10080 }
10081 }
10082
10083 return styles;
10084 }
10085
10086 function styleDifference( oldStyle, newStyle ) {
10087 var diff = {},
10088 name, value;
10089
10090 for ( name in newStyle ) {
10091 value = newStyle[ name ];
10092 if ( oldStyle[ name ] !== value ) {
10093 if ( !shorthandStyles[ name ] ) {
10094 if ( $.fx.step[ name ] || !isNaN( parseFloat( value ) ) ) {
10095 diff[ name ] = value;
10096 }
10097 }
10098 }
10099 }
10100
10101 return diff;
10102 }
10103
10104 // support: jQuery <1.8
10105 if ( !$.fn.addBack ) {
10106 $.fn.addBack = function( selector ) {
10107 return this.add( selector == null ?
10108 this.prevObject : this.prevObject.filter( selector )
10109 );
10110 };
10111 }
10112
10113 $.effects.animateClass = function( value, duration, easing, callback ) {
10114 var o = $.speed( duration, easing, callback );
10115
10116 return this.queue( function() {
10117 var animated = $( this ),
10118 baseClass = animated.attr( "class" ) || "",
10119 applyClassChange,
10120 allAnimations = o.children ? animated.find( "*" ).addBack() : animated;
10121
10122 // map the animated objects to store the original styles.
10123 allAnimations = allAnimations.map(function() {
10124 var el = $( this );
10125 return {
10126 el: el,
10127 start: getElementStyles( this )
10128 };
10129 });
10130
10131 // apply class change
10132 applyClassChange = function() {
10133 $.each( classAnimationActions, function(i, action) {
10134 if ( value[ action ] ) {
10135 animated[ action + "Class" ]( value[ action ] );
10136 }
10137 });
10138 };
10139 applyClassChange();
10140
10141 // map all animated objects again - calculate new styles and diff
10142 allAnimations = allAnimations.map(function() {
10143 this.end = getElementStyles( this.el[ 0 ] );
10144 this.diff = styleDifference( this.start, this.end );
10145 return this;
10146 });
10147
10148 // apply original class
10149 animated.attr( "class", baseClass );
10150
10151 // map all animated objects again - this time collecting a promise
10152 allAnimations = allAnimations.map(function() {
10153 var styleInfo = this,
10154 dfd = $.Deferred(),
10155 opts = $.extend({}, o, {
10156 queue: false,
10157 complete: function() {
10158 dfd.resolve( styleInfo );
10159 }
10160 });
10161
10162 this.el.animate( this.diff, opts );
10163 return dfd.promise();
10164 });
10165
10166 // once all animations have completed:
10167 $.when.apply( $, allAnimations.get() ).done(function() {
10168
10169 // set the final class
10170 applyClassChange();
10171
10172 // for each animated element,
10173 // clear all css properties that were animated
10174 $.each( arguments, function() {
10175 var el = this.el;
10176 $.each( this.diff, function(key) {
10177 el.css( key, "" );
10178 });
10179 });
10180
10181 // this is guarnteed to be there if you use jQuery.speed()
10182 // it also handles dequeuing the next anim...
10183 o.complete.call( animated[ 0 ] );
10184 });
10185 });
10186 };
10187
10188 $.fn.extend({
10189 addClass: (function( orig ) {
10190 return function( classNames, speed, easing, callback ) {
10191 return speed ?
10192 $.effects.animateClass.call( this,
10193 { add: classNames }, speed, easing, callback ) :
10194 orig.apply( this, arguments );
10195 };
10196 })( $.fn.addClass ),
10197
10198 removeClass: (function( orig ) {
10199 return function( classNames, speed, easing, callback ) {
10200 return arguments.length > 1 ?
10201 $.effects.animateClass.call( this,
10202 { remove: classNames }, speed, easing, callback ) :
10203 orig.apply( this, arguments );
10204 };
10205 })( $.fn.removeClass ),
10206
10207 toggleClass: (function( orig ) {
10208 return function( classNames, force, speed, easing, callback ) {
10209 if ( typeof force === "boolean" || force === undefined ) {
10210 if ( !speed ) {
10211 // without speed parameter
10212 return orig.apply( this, arguments );
10213 } else {
10214 return $.effects.animateClass.call( this,
10215 (force ? { add: classNames } : { remove: classNames }),
10216 speed, easing, callback );
10217 }
10218 } else {
10219 // without force parameter
10220 return $.effects.animateClass.call( this,
10221 { toggle: classNames }, force, speed, easing );
10222 }
10223 };
10224 })( $.fn.toggleClass ),
10225
10226 switchClass: function( remove, add, speed, easing, callback) {
10227 return $.effects.animateClass.call( this, {
10228 add: add,
10229 remove: remove
10230 }, speed, easing, callback );
10231 }
10232 });
10233
10234 })();
10235
10236 /******************************************************************************/
10237 /*********************************** EFFECTS **********************************/
10238 /******************************************************************************/
10239
10240 (function() {
10241
10242 $.extend( $.effects, {
10243 version: "1.11.4",
10244
10245 // Saves a set of properties in a data storage
10246 save: function( element, set ) {
10247 for ( var i = 0; i < set.length; i++ ) {
10248 if ( set[ i ] !== null ) {
10249 element.data( dataSpace + set[ i ], element[ 0 ].style[ set[ i ] ] );
10250 }
10251 }
10252 },
10253
10254 // Restores a set of previously saved properties from a data storage
10255 restore: function( element, set ) {
10256 var val, i;
10257 for ( i = 0; i < set.length; i++ ) {
10258 if ( set[ i ] !== null ) {
10259 val = element.data( dataSpace + set[ i ] );
10260 // support: jQuery 1.6.2
10261 // http://bugs.jquery.com/ticket/9917
10262 // jQuery 1.6.2 incorrectly returns undefined for any falsy value.
10263 // We can't differentiate between "" and 0 here, so we just assume
10264 // empty string since it's likely to be a more common value...
10265 if ( val === undefined ) {
10266 val = "";
10267 }
10268 element.css( set[ i ], val );
10269 }
10270 }
10271 },
10272
10273 setMode: function( el, mode ) {
10274 if (mode === "toggle") {
10275 mode = el.is( ":hidden" ) ? "show" : "hide";
10276 }
10277 return mode;
10278 },
10279
10280 // Translates a [top,left] array into a baseline value
10281 // this should be a little more flexible in the future to handle a string & hash
10282 getBaseline: function( origin, original ) {
10283 var y, x;
10284 switch ( origin[ 0 ] ) {
10285 case "top": y = 0; break;
10286 case "middle": y = 0.5; break;
10287 case "bottom": y = 1; break;
10288 default: y = origin[ 0 ] / original.height;
10289 }
10290 switch ( origin[ 1 ] ) {
10291 case "left": x = 0; break;
10292 case "center": x = 0.5; break;
10293 case "right": x = 1; break;
10294 default: x = origin[ 1 ] / original.width;
10295 }
10296 return {
10297 x: x,
10298 y: y
10299 };
10300 },
10301
10302 // Wraps the element around a wrapper that copies position properties
10303 createWrapper: function( element ) {
10304
10305 // if the element is already wrapped, return it
10306 if ( element.parent().is( ".ui-effects-wrapper" )) {
10307 return element.parent();
10308 }
10309
10310 // wrap the element
10311 var props = {
10312 width: element.outerWidth(true),
10313 height: element.outerHeight(true),
10314 "float": element.css( "float" )
10315 },
10316 wrapper = $( "<div></div>" )
10317 .addClass( "ui-effects-wrapper" )
10318 .css({
10319 fontSize: "100%",
10320 background: "transparent",
10321 border: "none",
10322 margin: 0,
10323 padding: 0
10324 }),
10325 // Store the size in case width/height are defined in % - Fixes #5245
10326 size = {
10327 width: element.width(),
10328 height: element.height()
10329 },
10330 active = document.activeElement;
10331
10332 // support: Firefox
10333 // Firefox incorrectly exposes anonymous content
10334 // https://bugzilla.mozilla.org/show_bug.cgi?id=561664
10335 try {
10336 active.id;
10337 } catch ( e ) {
10338 active = document.body;
10339 }
10340
10341 element.wrap( wrapper );
10342
10343 // Fixes #7595 - Elements lose focus when wrapped.
10344 if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
10345 $( active ).focus();
10346 }
10347
10348 wrapper = element.parent(); //Hotfix for jQuery 1.4 since some change in wrap() seems to actually lose the reference to the wrapped element
10349
10350 // transfer positioning properties to the wrapper
10351 if ( element.css( "position" ) === "static" ) {
10352 wrapper.css({ position: "relative" });
10353 element.css({ position: "relative" });
10354 } else {
10355 $.extend( props, {
10356 position: element.css( "position" ),
10357 zIndex: element.css( "z-index" )
10358 });
10359 $.each([ "top", "left", "bottom", "right" ], function(i, pos) {
10360 props[ pos ] = element.css( pos );
10361 if ( isNaN( parseInt( props[ pos ], 10 ) ) ) {
10362 props[ pos ] = "auto";
10363 }
10364 });
10365 element.css({
10366 position: "relative",
10367 top: 0,
10368 left: 0,
10369 right: "auto",
10370 bottom: "auto"
10371 });
10372 }
10373 element.css(size);
10374
10375 return wrapper.css( props ).show();
10376 },
10377
10378 removeWrapper: function( element ) {
10379 var active = document.activeElement;
10380
10381 if ( element.parent().is( ".ui-effects-wrapper" ) ) {
10382 element.parent().replaceWith( element );
10383
10384 // Fixes #7595 - Elements lose focus when wrapped.
10385 if ( element[ 0 ] === active || $.contains( element[ 0 ], active ) ) {
10386 $( active ).focus();
10387 }
10388 }
10389
10390 return element;
10391 },
10392
10393 setTransition: function( element, list, factor, value ) {
10394 value = value || {};
10395 $.each( list, function( i, x ) {
10396 var unit = element.cssUnit( x );
10397 if ( unit[ 0 ] > 0 ) {
10398 value[ x ] = unit[ 0 ] * factor + unit[ 1 ];
10399 }
10400 });
10401 return value;
10402 }
10403 });
10404
10405 // return an effect options object for the given parameters:
10406 function _normalizeArguments( effect, options, speed, callback ) {
10407
10408 // allow passing all options as the first parameter
10409 if ( $.isPlainObject( effect ) ) {
10410 options = effect;
10411 effect = effect.effect;
10412 }
10413
10414 // convert to an object
10415 effect = { effect: effect };
10416
10417 // catch (effect, null, ...)
10418 if ( options == null ) {
10419 options = {};
10420 }
10421
10422 // catch (effect, callback)
10423 if ( $.isFunction( options ) ) {
10424 callback = options;
10425 speed = null;
10426 options = {};
10427 }
10428
10429 // catch (effect, speed, ?)
10430 if ( typeof options === "number" || $.fx.speeds[ options ] ) {
10431 callback = speed;
10432 speed = options;
10433 options = {};
10434 }
10435
10436 // catch (effect, options, callback)
10437 if ( $.isFunction( speed ) ) {
10438 callback = speed;
10439 speed = null;
10440 }
10441
10442 // add options to effect
10443 if ( options ) {
10444 $.extend( effect, options );
10445 }
10446
10447 speed = speed || options.duration;
10448 effect.duration = $.fx.off ? 0 :
10449 typeof speed === "number" ? speed :
10450 speed in $.fx.speeds ? $.fx.speeds[ speed ] :
10451 $.fx.speeds._default;
10452
10453 effect.complete = callback || options.complete;
10454
10455 return effect;
10456 }
10457
10458 function standardAnimationOption( option ) {
10459 // Valid standard speeds (nothing, number, named speed)
10460 if ( !option || typeof option === "number" || $.fx.speeds[ option ] ) {
10461 return true;
10462 }
10463
10464 // Invalid strings - treat as "normal" speed
10465 if ( typeof option === "string" && !$.effects.effect[ option ] ) {
10466 return true;
10467 }
10468
10469 // Complete callback
10470 if ( $.isFunction( option ) ) {
10471 return true;
10472 }
10473
10474 // Options hash (but not naming an effect)
10475 if ( typeof option === "object" && !option.effect ) {
10476 return true;
10477 }
10478
10479 // Didn't match any standard API
10480 return false;
10481 }
10482
10483 $.fn.extend({
10484 effect: function( /* effect, options, speed, callback */ ) {
10485 var args = _normalizeArguments.apply( this, arguments ),
10486 mode = args.mode,
10487 queue = args.queue,
10488 effectMethod = $.effects.effect[ args.effect ];
10489
10490 if ( $.fx.off || !effectMethod ) {
10491 // delegate to the original method (e.g., .show()) if possible
10492 if ( mode ) {
10493 return this[ mode ]( args.duration, args.complete );
10494 } else {
10495 return this.each( function() {
10496 if ( args.complete ) {
10497 args.complete.call( this );
10498 }
10499 });
10500 }
10501 }
10502
10503 function run( next ) {
10504 var elem = $( this ),
10505 complete = args.complete,
10506 mode = args.mode;
10507
10508 function done() {
10509 if ( $.isFunction( complete ) ) {
10510 complete.call( elem[0] );
10511 }
10512 if ( $.isFunction( next ) ) {
10513 next();
10514 }
10515 }
10516
10517 // If the element already has the correct final state, delegate to
10518 // the core methods so the internal tracking of "olddisplay" works.
10519 if ( elem.is( ":hidden" ) ? mode === "hide" : mode === "show" ) {
10520 elem[ mode ]();
10521 done();
10522 } else {
10523 effectMethod.call( elem[0], args, done );
10524 }
10525 }
10526
10527 return queue === false ? this.each( run ) : this.queue( queue || "fx", run );
10528 },
10529
10530 show: (function( orig ) {
10531 return function( option ) {
10532 if ( standardAnimationOption( option ) ) {
10533 return orig.apply( this, arguments );
10534 } else {
10535 var args = _normalizeArguments.apply( this, arguments );
10536 args.mode = "show";
10537 return this.effect.call( this, args );
10538 }
10539 };
10540 })( $.fn.show ),
10541
10542 hide: (function( orig ) {
10543 return function( option ) {
10544 if ( standardAnimationOption( option ) ) {
10545 return orig.apply( this, arguments );
10546 } else {
10547 var args = _normalizeArguments.apply( this, arguments );
10548 args.mode = "hide";
10549 return this.effect.call( this, args );
10550 }
10551 };
10552 })( $.fn.hide ),
10553
10554 toggle: (function( orig ) {
10555 return function( option ) {
10556 if ( standardAnimationOption( option ) || typeof option === "boolean" ) {
10557 return orig.apply( this, arguments );
10558 } else {
10559 var args = _normalizeArguments.apply( this, arguments );
10560 args.mode = "toggle";
10561 return this.effect.call( this, args );
10562 }
10563 };
10564 })( $.fn.toggle ),
10565
10566 // helper functions
10567 cssUnit: function(key) {
10568 var style = this.css( key ),
10569 val = [];
10570
10571 $.each( [ "em", "px", "%", "pt" ], function( i, unit ) {
10572 if ( style.indexOf( unit ) > 0 ) {
10573 val = [ parseFloat( style ), unit ];
10574 }
10575 });
10576 return val;
10577 }
10578 });
10579
10580 })();
10581
10582 /******************************************************************************/
10583 /*********************************** EASING ***********************************/
10584 /******************************************************************************/
10585
10586 (function() {
10587
10588 // based on easing equations from Robert Penner (http://www.robertpenner.com/easing)
10589
10590 var baseEasings = {};
10591
10592 $.each( [ "Quad", "Cubic", "Quart", "Quint", "Expo" ], function( i, name ) {
10593 baseEasings[ name ] = function( p ) {
10594 return Math.pow( p, i + 2 );
10595 };
10596 });
10597
10598 $.extend( baseEasings, {
10599 Sine: function( p ) {
10600 return 1 - Math.cos( p * Math.PI / 2 );
10601 },
10602 Circ: function( p ) {
10603 return 1 - Math.sqrt( 1 - p * p );
10604 },
10605 Elastic: function( p ) {
10606 return p === 0 || p === 1 ? p :
10607 -Math.pow( 2, 8 * (p - 1) ) * Math.sin( ( (p - 1) * 80 - 7.5 ) * Math.PI / 15 );
10608 },
10609 Back: function( p ) {
10610 return p * p * ( 3 * p - 2 );
10611 },
10612 Bounce: function( p ) {
10613 var pow2,
10614 bounce = 4;
10615
10616 while ( p < ( ( pow2 = Math.pow( 2, --bounce ) ) - 1 ) / 11 ) {}
10617 return 1 / Math.pow( 4, 3 - bounce ) - 7.5625 * Math.pow( ( pow2 * 3 - 2 ) / 22 - p, 2 );
10618 }
10619 });
10620
10621 $.each( baseEasings, function( name, easeIn ) {
10622 $.easing[ "easeIn" + name ] = easeIn;
10623 $.easing[ "easeOut" + name ] = function( p ) {
10624 return 1 - easeIn( 1 - p );
10625 };
10626 $.easing[ "easeInOut" + name ] = function( p ) {
10627 return p < 0.5 ?
10628 easeIn( p * 2 ) / 2 :
10629 1 - easeIn( p * -2 + 2 ) / 2;
10630 };
10631 });
10632
10633 })();
10634
10635 var effect = $.effects;
10636
10637
10638 /*!
10639 * jQuery UI Effects Blind 1.11.4
10640 * http://jqueryui.com
10641 *
10642 * Copyright jQuery Foundation and other contributors
10643 * Released under the MIT license.
10644 * http://jquery.org/license
10645 *
10646 * http://api.jqueryui.com/blind-effect/
10647 */
10648
10649
10650 var effectBlind = $.effects.effect.blind = function( o, done ) {
10651 // Create element
10652 var el = $( this ),
10653 rvertical = /up|down|vertical/,
10654 rpositivemotion = /up|left|vertical|horizontal/,
10655 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
10656 mode = $.effects.setMode( el, o.mode || "hide" ),
10657 direction = o.direction || "up",
10658 vertical = rvertical.test( direction ),
10659 ref = vertical ? "height" : "width",
10660 ref2 = vertical ? "top" : "left",
10661 motion = rpositivemotion.test( direction ),
10662 animation = {},
10663 show = mode === "show",
10664 wrapper, distance, margin;
10665
10666 // if already wrapped, the wrapper's properties are my property. #6245
10667 if ( el.parent().is( ".ui-effects-wrapper" ) ) {
10668 $.effects.save( el.parent(), props );
10669 } else {
10670 $.effects.save( el, props );
10671 }
10672 el.show();
10673 wrapper = $.effects.createWrapper( el ).css({
10674 overflow: "hidden"
10675 });
10676
10677 distance = wrapper[ ref ]();
10678 margin = parseFloat( wrapper.css( ref2 ) ) || 0;
10679
10680 animation[ ref ] = show ? distance : 0;
10681 if ( !motion ) {
10682 el
10683 .css( vertical ? "bottom" : "right", 0 )
10684 .css( vertical ? "top" : "left", "auto" )
10685 .css({ position: "absolute" });
10686
10687 animation[ ref2 ] = show ? margin : distance + margin;
10688 }
10689
10690 // start at 0 if we are showing
10691 if ( show ) {
10692 wrapper.css( ref, 0 );
10693 if ( !motion ) {
10694 wrapper.css( ref2, margin + distance );
10695 }
10696 }
10697
10698 // Animate
10699 wrapper.animate( animation, {
10700 duration: o.duration,
10701 easing: o.easing,
10702 queue: false,
10703 complete: function() {
10704 if ( mode === "hide" ) {
10705 el.hide();
10706 }
10707 $.effects.restore( el, props );
10708 $.effects.removeWrapper( el );
10709 done();
10710 }
10711 });
10712 };
10713
10714
10715 /*!
10716 * jQuery UI Effects Bounce 1.11.4
10717 * http://jqueryui.com
10718 *
10719 * Copyright jQuery Foundation and other contributors
10720 * Released under the MIT license.
10721 * http://jquery.org/license
10722 *
10723 * http://api.jqueryui.com/bounce-effect/
10724 */
10725
10726
10727 var effectBounce = $.effects.effect.bounce = function( o, done ) {
10728 var el = $( this ),
10729 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
10730
10731 // defaults:
10732 mode = $.effects.setMode( el, o.mode || "effect" ),
10733 hide = mode === "hide",
10734 show = mode === "show",
10735 direction = o.direction || "up",
10736 distance = o.distance,
10737 times = o.times || 5,
10738
10739 // number of internal animations
10740 anims = times * 2 + ( show || hide ? 1 : 0 ),
10741 speed = o.duration / anims,
10742 easing = o.easing,
10743
10744 // utility:
10745 ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
10746 motion = ( direction === "up" || direction === "left" ),
10747 i,
10748 upAnim,
10749 downAnim,
10750
10751 // we will need to re-assemble the queue to stack our animations in place
10752 queue = el.queue(),
10753 queuelen = queue.length;
10754
10755 // Avoid touching opacity to prevent clearType and PNG issues in IE
10756 if ( show || hide ) {
10757 props.push( "opacity" );
10758 }
10759
10760 $.effects.save( el, props );
10761 el.show();
10762 $.effects.createWrapper( el ); // Create Wrapper
10763
10764 // default distance for the BIGGEST bounce is the outer Distance / 3
10765 if ( !distance ) {
10766 distance = el[ ref === "top" ? "outerHeight" : "outerWidth" ]() / 3;
10767 }
10768
10769 if ( show ) {
10770 downAnim = { opacity: 1 };
10771 downAnim[ ref ] = 0;
10772
10773 // if we are showing, force opacity 0 and set the initial position
10774 // then do the "first" animation
10775 el.css( "opacity", 0 )
10776 .css( ref, motion ? -distance * 2 : distance * 2 )
10777 .animate( downAnim, speed, easing );
10778 }
10779
10780 // start at the smallest distance if we are hiding
10781 if ( hide ) {
10782 distance = distance / Math.pow( 2, times - 1 );
10783 }
10784
10785 downAnim = {};
10786 downAnim[ ref ] = 0;
10787 // Bounces up/down/left/right then back to 0 -- times * 2 animations happen here
10788 for ( i = 0; i < times; i++ ) {
10789 upAnim = {};
10790 upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance;
10791
10792 el.animate( upAnim, speed, easing )
10793 .animate( downAnim, speed, easing );
10794
10795 distance = hide ? distance * 2 : distance / 2;
10796 }
10797
10798 // Last Bounce when Hiding
10799 if ( hide ) {
10800 upAnim = { opacity: 0 };
10801 upAnim[ ref ] = ( motion ? "-=" : "+=" ) + distance;
10802
10803 el.animate( upAnim, speed, easing );
10804 }
10805
10806 el.queue(function() {
10807 if ( hide ) {
10808 el.hide();
10809 }
10810 $.effects.restore( el, props );
10811 $.effects.removeWrapper( el );
10812 done();
10813 });
10814
10815 // inject all the animations we just queued to be first in line (after "inprogress")
10816 if ( queuelen > 1) {
10817 queue.splice.apply( queue,
10818 [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
10819 }
10820 el.dequeue();
10821
10822 };
10823
10824
10825 /*!
10826 * jQuery UI Effects Clip 1.11.4
10827 * http://jqueryui.com
10828 *
10829 * Copyright jQuery Foundation and other contributors
10830 * Released under the MIT license.
10831 * http://jquery.org/license
10832 *
10833 * http://api.jqueryui.com/clip-effect/
10834 */
10835
10836
10837 var effectClip = $.effects.effect.clip = function( o, done ) {
10838 // Create element
10839 var el = $( this ),
10840 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
10841 mode = $.effects.setMode( el, o.mode || "hide" ),
10842 show = mode === "show",
10843 direction = o.direction || "vertical",
10844 vert = direction === "vertical",
10845 size = vert ? "height" : "width",
10846 position = vert ? "top" : "left",
10847 animation = {},
10848 wrapper, animate, distance;
10849
10850 // Save & Show
10851 $.effects.save( el, props );
10852 el.show();
10853
10854 // Create Wrapper
10855 wrapper = $.effects.createWrapper( el ).css({
10856 overflow: "hidden"
10857 });
10858 animate = ( el[0].tagName === "IMG" ) ? wrapper : el;
10859 distance = animate[ size ]();
10860
10861 // Shift
10862 if ( show ) {
10863 animate.css( size, 0 );
10864 animate.css( position, distance / 2 );
10865 }
10866
10867 // Create Animation Object:
10868 animation[ size ] = show ? distance : 0;
10869 animation[ position ] = show ? 0 : distance / 2;
10870
10871 // Animate
10872 animate.animate( animation, {
10873 queue: false,
10874 duration: o.duration,
10875 easing: o.easing,
10876 complete: function() {
10877 if ( !show ) {
10878 el.hide();
10879 }
10880 $.effects.restore( el, props );
10881 $.effects.removeWrapper( el );
10882 done();
10883 }
10884 });
10885
10886 };
10887
10888
10889 /*!
10890 * jQuery UI Effects Drop 1.11.4
10891 * http://jqueryui.com
10892 *
10893 * Copyright jQuery Foundation and other contributors
10894 * Released under the MIT license.
10895 * http://jquery.org/license
10896 *
10897 * http://api.jqueryui.com/drop-effect/
10898 */
10899
10900
10901 var effectDrop = $.effects.effect.drop = function( o, done ) {
10902
10903 var el = $( this ),
10904 props = [ "position", "top", "bottom", "left", "right", "opacity", "height", "width" ],
10905 mode = $.effects.setMode( el, o.mode || "hide" ),
10906 show = mode === "show",
10907 direction = o.direction || "left",
10908 ref = ( direction === "up" || direction === "down" ) ? "top" : "left",
10909 motion = ( direction === "up" || direction === "left" ) ? "pos" : "neg",
10910 animation = {
10911 opacity: show ? 1 : 0
10912 },
10913 distance;
10914
10915 // Adjust
10916 $.effects.save( el, props );
10917 el.show();
10918 $.effects.createWrapper( el );
10919
10920 distance = o.distance || el[ ref === "top" ? "outerHeight" : "outerWidth" ]( true ) / 2;
10921
10922 if ( show ) {
10923 el
10924 .css( "opacity", 0 )
10925 .css( ref, motion === "pos" ? -distance : distance );
10926 }
10927
10928 // Animation
10929 animation[ ref ] = ( show ?
10930 ( motion === "pos" ? "+=" : "-=" ) :
10931 ( motion === "pos" ? "-=" : "+=" ) ) +
10932 distance;
10933
10934 // Animate
10935 el.animate( animation, {
10936 queue: false,
10937 duration: o.duration,
10938 easing: o.easing,
10939 complete: function() {
10940 if ( mode === "hide" ) {
10941 el.hide();
10942 }
10943 $.effects.restore( el, props );
10944 $.effects.removeWrapper( el );
10945 done();
10946 }
10947 });
10948 };
10949
10950
10951 /*!
10952 * jQuery UI Effects Explode 1.11.4
10953 * http://jqueryui.com
10954 *
10955 * Copyright jQuery Foundation and other contributors
10956 * Released under the MIT license.
10957 * http://jquery.org/license
10958 *
10959 * http://api.jqueryui.com/explode-effect/
10960 */
10961
10962
10963 var effectExplode = $.effects.effect.explode = function( o, done ) {
10964
10965 var rows = o.pieces ? Math.round( Math.sqrt( o.pieces ) ) : 3,
10966 cells = rows,
10967 el = $( this ),
10968 mode = $.effects.setMode( el, o.mode || "hide" ),
10969 show = mode === "show",
10970
10971 // show and then visibility:hidden the element before calculating offset
10972 offset = el.show().css( "visibility", "hidden" ).offset(),
10973
10974 // width and height of a piece
10975 width = Math.ceil( el.outerWidth() / cells ),
10976 height = Math.ceil( el.outerHeight() / rows ),
10977 pieces = [],
10978
10979 // loop
10980 i, j, left, top, mx, my;
10981
10982 // children animate complete:
10983 function childComplete() {
10984 pieces.push( this );
10985 if ( pieces.length === rows * cells ) {
10986 animComplete();
10987 }
10988 }
10989
10990 // clone the element for each row and cell.
10991 for ( i = 0; i < rows ; i++ ) { // ===>
10992 top = offset.top + i * height;
10993 my = i - ( rows - 1 ) / 2 ;
10994
10995 for ( j = 0; j < cells ; j++ ) { // |||
10996 left = offset.left + j * width;
10997 mx = j - ( cells - 1 ) / 2 ;
10998
10999 // Create a clone of the now hidden main element that will be absolute positioned
11000 // within a wrapper div off the -left and -top equal to size of our pieces
11001 el
11002 .clone()
11003 .appendTo( "body" )
11004 .wrap( "<div></div>" )
11005 .css({
11006 position: "absolute",
11007 visibility: "visible",
11008 left: -j * width,
11009 top: -i * height
11010 })
11011
11012 // select the wrapper - make it overflow: hidden and absolute positioned based on
11013 // where the original was located +left and +top equal to the size of pieces
11014 .parent()
11015 .addClass( "ui-effects-explode" )
11016 .css({
11017 position: "absolute",
11018 overflow: "hidden",
11019 width: width,
11020 height: height,
11021 left: left + ( show ? mx * width : 0 ),
11022 top: top + ( show ? my * height : 0 ),
11023 opacity: show ? 0 : 1
11024 }).animate({
11025 left: left + ( show ? 0 : mx * width ),
11026 top: top + ( show ? 0 : my * height ),
11027 opacity: show ? 1 : 0
11028 }, o.duration || 500, o.easing, childComplete );
11029 }
11030 }
11031
11032 function animComplete() {
11033 el.css({
11034 visibility: "visible"
11035 });
11036 $( pieces ).remove();
11037 if ( !show ) {
11038 el.hide();
11039 }
11040 done();
11041 }
11042 };
11043
11044
11045 /*!
11046 * jQuery UI Effects Fade 1.11.4
11047 * http://jqueryui.com
11048 *
11049 * Copyright jQuery Foundation and other contributors
11050 * Released under the MIT license.
11051 * http://jquery.org/license
11052 *
11053 * http://api.jqueryui.com/fade-effect/
11054 */
11055
11056
11057 var effectFade = $.effects.effect.fade = function( o, done ) {
11058 var el = $( this ),
11059 mode = $.effects.setMode( el, o.mode || "toggle" );
11060
11061 el.animate({
11062 opacity: mode
11063 }, {
11064 queue: false,
11065 duration: o.duration,
11066 easing: o.easing,
11067 complete: done
11068 });
11069 };
11070
11071
11072 /*!
11073 * jQuery UI Effects Fold 1.11.4
11074 * http://jqueryui.com
11075 *
11076 * Copyright jQuery Foundation and other contributors
11077 * Released under the MIT license.
11078 * http://jquery.org/license
11079 *
11080 * http://api.jqueryui.com/fold-effect/
11081 */
11082
11083
11084 var effectFold = $.effects.effect.fold = function( o, done ) {
11085
11086 // Create element
11087 var el = $( this ),
11088 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
11089 mode = $.effects.setMode( el, o.mode || "hide" ),
11090 show = mode === "show",
11091 hide = mode === "hide",
11092 size = o.size || 15,
11093 percent = /([0-9]+)%/.exec( size ),
11094 horizFirst = !!o.horizFirst,
11095 widthFirst = show !== horizFirst,
11096 ref = widthFirst ? [ "width", "height" ] : [ "height", "width" ],
11097 duration = o.duration / 2,
11098 wrapper, distance,
11099 animation1 = {},
11100 animation2 = {};
11101
11102 $.effects.save( el, props );
11103 el.show();
11104
11105 // Create Wrapper
11106 wrapper = $.effects.createWrapper( el ).css({
11107 overflow: "hidden"
11108 });
11109 distance = widthFirst ?
11110 [ wrapper.width(), wrapper.height() ] :
11111 [ wrapper.height(), wrapper.width() ];
11112
11113 if ( percent ) {
11114 size = parseInt( percent[ 1 ], 10 ) / 100 * distance[ hide ? 0 : 1 ];
11115 }
11116 if ( show ) {
11117 wrapper.css( horizFirst ? {
11118 height: 0,
11119 width: size
11120 } : {
11121 height: size,
11122 width: 0
11123 });
11124 }
11125
11126 // Animation
11127 animation1[ ref[ 0 ] ] = show ? distance[ 0 ] : size;
11128 animation2[ ref[ 1 ] ] = show ? distance[ 1 ] : 0;
11129
11130 // Animate
11131 wrapper
11132 .animate( animation1, duration, o.easing )
11133 .animate( animation2, duration, o.easing, function() {
11134 if ( hide ) {
11135 el.hide();
11136 }
11137 $.effects.restore( el, props );
11138 $.effects.removeWrapper( el );
11139 done();
11140 });
11141
11142 };
11143
11144
11145 /*!
11146 * jQuery UI Effects Highlight 1.11.4
11147 * http://jqueryui.com
11148 *
11149 * Copyright jQuery Foundation and other contributors
11150 * Released under the MIT license.
11151 * http://jquery.org/license
11152 *
11153 * http://api.jqueryui.com/highlight-effect/
11154 */
11155
11156
11157 var effectHighlight = $.effects.effect.highlight = function( o, done ) {
11158 var elem = $( this ),
11159 props = [ "backgroundImage", "backgroundColor", "opacity" ],
11160 mode = $.effects.setMode( elem, o.mode || "show" ),
11161 animation = {
11162 backgroundColor: elem.css( "backgroundColor" )
11163 };
11164
11165 if (mode === "hide") {
11166 animation.opacity = 0;
11167 }
11168
11169 $.effects.save( elem, props );
11170
11171 elem
11172 .show()
11173 .css({
11174 backgroundImage: "none",
11175 backgroundColor: o.color || "#ffff99"
11176 })
11177 .animate( animation, {
11178 queue: false,
11179 duration: o.duration,
11180 easing: o.easing,
11181 complete: function() {
11182 if ( mode === "hide" ) {
11183 elem.hide();
11184 }
11185 $.effects.restore( elem, props );
11186 done();
11187 }
11188 });
11189 };
11190
11191
11192 /*!
11193 * jQuery UI Effects Size 1.11.4
11194 * http://jqueryui.com
11195 *
11196 * Copyright jQuery Foundation and other contributors
11197 * Released under the MIT license.
11198 * http://jquery.org/license
11199 *
11200 * http://api.jqueryui.com/size-effect/
11201 */
11202
11203
11204 var effectSize = $.effects.effect.size = function( o, done ) {
11205
11206 // Create element
11207 var original, baseline, factor,
11208 el = $( this ),
11209 props0 = [ "position", "top", "bottom", "left", "right", "width", "height", "overflow", "opacity" ],
11210
11211 // Always restore
11212 props1 = [ "position", "top", "bottom", "left", "right", "overflow", "opacity" ],
11213
11214 // Copy for children
11215 props2 = [ "width", "height", "overflow" ],
11216 cProps = [ "fontSize" ],
11217 vProps = [ "borderTopWidth", "borderBottomWidth", "paddingTop", "paddingBottom" ],
11218 hProps = [ "borderLeftWidth", "borderRightWidth", "paddingLeft", "paddingRight" ],
11219
11220 // Set options
11221 mode = $.effects.setMode( el, o.mode || "effect" ),
11222 restore = o.restore || mode !== "effect",
11223 scale = o.scale || "both",
11224 origin = o.origin || [ "middle", "center" ],
11225 position = el.css( "position" ),
11226 props = restore ? props0 : props1,
11227 zero = {
11228 height: 0,
11229 width: 0,
11230 outerHeight: 0,
11231 outerWidth: 0
11232 };
11233
11234 if ( mode === "show" ) {
11235 el.show();
11236 }
11237 original = {
11238 height: el.height(),
11239 width: el.width(),
11240 outerHeight: el.outerHeight(),
11241 outerWidth: el.outerWidth()
11242 };
11243
11244 if ( o.mode === "toggle" && mode === "show" ) {
11245 el.from = o.to || zero;
11246 el.to = o.from || original;
11247 } else {
11248 el.from = o.from || ( mode === "show" ? zero : original );
11249 el.to = o.to || ( mode === "hide" ? zero : original );
11250 }
11251
11252 // Set scaling factor
11253 factor = {
11254 from: {
11255 y: el.from.height / original.height,
11256 x: el.from.width / original.width
11257 },
11258 to: {
11259 y: el.to.height / original.height,
11260 x: el.to.width / original.width
11261 }
11262 };
11263
11264 // Scale the css box
11265 if ( scale === "box" || scale === "both" ) {
11266
11267 // Vertical props scaling
11268 if ( factor.from.y !== factor.to.y ) {
11269 props = props.concat( vProps );
11270 el.from = $.effects.setTransition( el, vProps, factor.from.y, el.from );
11271 el.to = $.effects.setTransition( el, vProps, factor.to.y, el.to );
11272 }
11273
11274 // Horizontal props scaling
11275 if ( factor.from.x !== factor.to.x ) {
11276 props = props.concat( hProps );
11277 el.from = $.effects.setTransition( el, hProps, factor.from.x, el.from );
11278 el.to = $.effects.setTransition( el, hProps, factor.to.x, el.to );
11279 }
11280 }
11281
11282 // Scale the content
11283 if ( scale === "content" || scale === "both" ) {
11284
11285 // Vertical props scaling
11286 if ( factor.from.y !== factor.to.y ) {
11287 props = props.concat( cProps ).concat( props2 );
11288 el.from = $.effects.setTransition( el, cProps, factor.from.y, el.from );
11289 el.to = $.effects.setTransition( el, cProps, factor.to.y, el.to );
11290 }
11291 }
11292
11293 $.effects.save( el, props );
11294 el.show();
11295 $.effects.createWrapper( el );
11296 el.css( "overflow", "hidden" ).css( el.from );
11297
11298 // Adjust
11299 if (origin) { // Calculate baseline shifts
11300 baseline = $.effects.getBaseline( origin, original );
11301 el.from.top = ( original.outerHeight - el.outerHeight() ) * baseline.y;
11302 el.from.left = ( original.outerWidth - el.outerWidth() ) * baseline.x;
11303 el.to.top = ( original.outerHeight - el.to.outerHeight ) * baseline.y;
11304 el.to.left = ( original.outerWidth - el.to.outerWidth ) * baseline.x;
11305 }
11306 el.css( el.from ); // set top & left
11307
11308 // Animate
11309 if ( scale === "content" || scale === "both" ) { // Scale the children
11310
11311 // Add margins/font-size
11312 vProps = vProps.concat([ "marginTop", "marginBottom" ]).concat(cProps);
11313 hProps = hProps.concat([ "marginLeft", "marginRight" ]);
11314 props2 = props0.concat(vProps).concat(hProps);
11315
11316 el.find( "*[width]" ).each( function() {
11317 var child = $( this ),
11318 c_original = {
11319 height: child.height(),
11320 width: child.width(),
11321 outerHeight: child.outerHeight(),
11322 outerWidth: child.outerWidth()
11323 };
11324 if (restore) {
11325 $.effects.save(child, props2);
11326 }
11327
11328 child.from = {
11329 height: c_original.height * factor.from.y,
11330 width: c_original.width * factor.from.x,
11331 outerHeight: c_original.outerHeight * factor.from.y,
11332 outerWidth: c_original.outerWidth * factor.from.x
11333 };
11334 child.to = {
11335 height: c_original.height * factor.to.y,
11336 width: c_original.width * factor.to.x,
11337 outerHeight: c_original.height * factor.to.y,
11338 outerWidth: c_original.width * factor.to.x
11339 };
11340
11341 // Vertical props scaling
11342 if ( factor.from.y !== factor.to.y ) {
11343 child.from = $.effects.setTransition( child, vProps, factor.from.y, child.from );
11344 child.to = $.effects.setTransition( child, vProps, factor.to.y, child.to );
11345 }
11346
11347 // Horizontal props scaling
11348 if ( factor.from.x !== factor.to.x ) {
11349 child.from = $.effects.setTransition( child, hProps, factor.from.x, child.from );
11350 child.to = $.effects.setTransition( child, hProps, factor.to.x, child.to );
11351 }
11352
11353 // Animate children
11354 child.css( child.from );
11355 child.animate( child.to, o.duration, o.easing, function() {
11356
11357 // Restore children
11358 if ( restore ) {
11359 $.effects.restore( child, props2 );
11360 }
11361 });
11362 });
11363 }
11364
11365 // Animate
11366 el.animate( el.to, {
11367 queue: false,
11368 duration: o.duration,
11369 easing: o.easing,
11370 complete: function() {
11371 if ( el.to.opacity === 0 ) {
11372 el.css( "opacity", el.from.opacity );
11373 }
11374 if ( mode === "hide" ) {
11375 el.hide();
11376 }
11377 $.effects.restore( el, props );
11378 if ( !restore ) {
11379
11380 // we need to calculate our new positioning based on the scaling
11381 if ( position === "static" ) {
11382 el.css({
11383 position: "relative",
11384 top: el.to.top,
11385 left: el.to.left
11386 });
11387 } else {
11388 $.each([ "top", "left" ], function( idx, pos ) {
11389 el.css( pos, function( _, str ) {
11390 var val = parseInt( str, 10 ),
11391 toRef = idx ? el.to.left : el.to.top;
11392
11393 // if original was "auto", recalculate the new value from wrapper
11394 if ( str === "auto" ) {
11395 return toRef + "px";
11396 }
11397
11398 return val + toRef + "px";
11399 });
11400 });
11401 }
11402 }
11403
11404 $.effects.removeWrapper( el );
11405 done();
11406 }
11407 });
11408
11409 };
11410
11411
11412 /*!
11413 * jQuery UI Effects Scale 1.11.4
11414 * http://jqueryui.com
11415 *
11416 * Copyright jQuery Foundation and other contributors
11417 * Released under the MIT license.
11418 * http://jquery.org/license
11419 *
11420 * http://api.jqueryui.com/scale-effect/
11421 */
11422
11423
11424 var effectScale = $.effects.effect.scale = function( o, done ) {
11425
11426 // Create element
11427 var el = $( this ),
11428 options = $.extend( true, {}, o ),
11429 mode = $.effects.setMode( el, o.mode || "effect" ),
11430 percent = parseInt( o.percent, 10 ) ||
11431 ( parseInt( o.percent, 10 ) === 0 ? 0 : ( mode === "hide" ? 0 : 100 ) ),
11432 direction = o.direction || "both",
11433 origin = o.origin,
11434 original = {
11435 height: el.height(),
11436 width: el.width(),
11437 outerHeight: el.outerHeight(),
11438 outerWidth: el.outerWidth()
11439 },
11440 factor = {
11441 y: direction !== "horizontal" ? (percent / 100) : 1,
11442 x: direction !== "vertical" ? (percent / 100) : 1
11443 };
11444
11445 // We are going to pass this effect to the size effect:
11446 options.effect = "size";
11447 options.queue = false;
11448 options.complete = done;
11449
11450 // Set default origin and restore for show/hide
11451 if ( mode !== "effect" ) {
11452 options.origin = origin || [ "middle", "center" ];
11453 options.restore = true;
11454 }
11455
11456 options.from = o.from || ( mode === "show" ? {
11457 height: 0,
11458 width: 0,
11459 outerHeight: 0,
11460 outerWidth: 0
11461 } : original );
11462 options.to = {
11463 height: original.height * factor.y,
11464 width: original.width * factor.x,
11465 outerHeight: original.outerHeight * factor.y,
11466 outerWidth: original.outerWidth * factor.x
11467 };
11468
11469 // Fade option to support puff
11470 if ( options.fade ) {
11471 if ( mode === "show" ) {
11472 options.from.opacity = 0;
11473 options.to.opacity = 1;
11474 }
11475 if ( mode === "hide" ) {
11476 options.from.opacity = 1;
11477 options.to.opacity = 0;
11478 }
11479 }
11480
11481 // Animate
11482 el.effect( options );
11483
11484 };
11485
11486
11487 /*!
11488 * jQuery UI Effects Puff 1.11.4
11489 * http://jqueryui.com
11490 *
11491 * Copyright jQuery Foundation and other contributors
11492 * Released under the MIT license.
11493 * http://jquery.org/license
11494 *
11495 * http://api.jqueryui.com/puff-effect/
11496 */
11497
11498
11499 var effectPuff = $.effects.effect.puff = function( o, done ) {
11500 var elem = $( this ),
11501 mode = $.effects.setMode( elem, o.mode || "hide" ),
11502 hide = mode === "hide",
11503 percent = parseInt( o.percent, 10 ) || 150,
11504 factor = percent / 100,
11505 original = {
11506 height: elem.height(),
11507 width: elem.width(),
11508 outerHeight: elem.outerHeight(),
11509 outerWidth: elem.outerWidth()
11510 };
11511
11512 $.extend( o, {
11513 effect: "scale",
11514 queue: false,
11515 fade: true,
11516 mode: mode,
11517 complete: done,
11518 percent: hide ? percent : 100,
11519 from: hide ?
11520 original :
11521 {
11522 height: original.height * factor,
11523 width: original.width * factor,
11524 outerHeight: original.outerHeight * factor,
11525 outerWidth: original.outerWidth * factor
11526 }
11527 });
11528
11529 elem.effect( o );
11530 };
11531
11532
11533 /*!
11534 * jQuery UI Effects Pulsate 1.11.4
11535 * http://jqueryui.com
11536 *
11537 * Copyright jQuery Foundation and other contributors
11538 * Released under the MIT license.
11539 * http://jquery.org/license
11540 *
11541 * http://api.jqueryui.com/pulsate-effect/
11542 */
11543
11544
11545 var effectPulsate = $.effects.effect.pulsate = function( o, done ) {
11546 var elem = $( this ),
11547 mode = $.effects.setMode( elem, o.mode || "show" ),
11548 show = mode === "show",
11549 hide = mode === "hide",
11550 showhide = ( show || mode === "hide" ),
11551
11552 // showing or hiding leaves of the "last" animation
11553 anims = ( ( o.times || 5 ) * 2 ) + ( showhide ? 1 : 0 ),
11554 duration = o.duration / anims,
11555 animateTo = 0,
11556 queue = elem.queue(),
11557 queuelen = queue.length,
11558 i;
11559
11560 if ( show || !elem.is(":visible")) {
11561 elem.css( "opacity", 0 ).show();
11562 animateTo = 1;
11563 }
11564
11565 // anims - 1 opacity "toggles"
11566 for ( i = 1; i < anims; i++ ) {
11567 elem.animate({
11568 opacity: animateTo
11569 }, duration, o.easing );
11570 animateTo = 1 - animateTo;
11571 }
11572
11573 elem.animate({
11574 opacity: animateTo
11575 }, duration, o.easing);
11576
11577 elem.queue(function() {
11578 if ( hide ) {
11579 elem.hide();
11580 }
11581 done();
11582 });
11583
11584 // We just queued up "anims" animations, we need to put them next in the queue
11585 if ( queuelen > 1 ) {
11586 queue.splice.apply( queue,
11587 [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
11588 }
11589 elem.dequeue();
11590 };
11591
11592
11593 /*!
11594 * jQuery UI Effects Shake 1.11.4
11595 * http://jqueryui.com
11596 *
11597 * Copyright jQuery Foundation and other contributors
11598 * Released under the MIT license.
11599 * http://jquery.org/license
11600 *
11601 * http://api.jqueryui.com/shake-effect/
11602 */
11603
11604
11605 var effectShake = $.effects.effect.shake = function( o, done ) {
11606
11607 var el = $( this ),
11608 props = [ "position", "top", "bottom", "left", "right", "height", "width" ],
11609 mode = $.effects.setMode( el, o.mode || "effect" ),
11610 direction = o.direction || "left",
11611 distance = o.distance || 20,
11612 times = o.times || 3,
11613 anims = times * 2 + 1,
11614 speed = Math.round( o.duration / anims ),
11615 ref = (direction === "up" || direction === "down") ? "top" : "left",
11616 positiveMotion = (direction === "up" || direction === "left"),
11617 animation = {},
11618 animation1 = {},
11619 animation2 = {},
11620 i,
11621
11622 // we will need to re-assemble the queue to stack our animations in place
11623 queue = el.queue(),
11624 queuelen = queue.length;
11625
11626 $.effects.save( el, props );
11627 el.show();
11628 $.effects.createWrapper( el );
11629
11630 // Animation
11631 animation[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance;
11632 animation1[ ref ] = ( positiveMotion ? "+=" : "-=" ) + distance * 2;
11633 animation2[ ref ] = ( positiveMotion ? "-=" : "+=" ) + distance * 2;
11634
11635 // Animate
11636 el.animate( animation, speed, o.easing );
11637
11638 // Shakes
11639 for ( i = 1; i < times; i++ ) {
11640 el.animate( animation1, speed, o.easing ).animate( animation2, speed, o.easing );
11641 }
11642 el
11643 .animate( animation1, speed, o.easing )
11644 .animate( animation, speed / 2, o.easing )
11645 .queue(function() {
11646 if ( mode === "hide" ) {
11647 el.hide();
11648 }
11649 $.effects.restore( el, props );
11650 $.effects.removeWrapper( el );
11651 done();
11652 });
11653
11654 // inject all the animations we just queued to be first in line (after "inprogress")
11655 if ( queuelen > 1) {
11656 queue.splice.apply( queue,
11657 [ 1, 0 ].concat( queue.splice( queuelen, anims + 1 ) ) );
11658 }
11659 el.dequeue();
11660
11661 };
11662
11663
11664 /*!
11665 * jQuery UI Effects Slide 1.11.4
11666 * http://jqueryui.com
11667 *
11668 * Copyright jQuery Foundation and other contributors
11669 * Released under the MIT license.
11670 * http://jquery.org/license
11671 *
11672 * http://api.jqueryui.com/slide-effect/
11673 */
11674
11675
11676 var effectSlide = $.effects.effect.slide = function( o, done ) {
11677
11678 // Create element
11679 var el = $( this ),
11680 props = [ "position", "top", "bottom", "left", "right", "width", "height" ],
11681 mode = $.effects.setMode( el, o.mode || "show" ),
11682 show = mode === "show",
11683 direction = o.direction || "left",
11684 ref = (direction === "up" || direction === "down") ? "top" : "left",
11685 positiveMotion = (direction === "up" || direction === "left"),
11686 distance,
11687 animation = {};
11688
11689 // Adjust
11690 $.effects.save( el, props );
11691 el.show();
11692 distance = o.distance || el[ ref === "top" ? "outerHeight" : "outerWidth" ]( true );
11693
11694 $.effects.createWrapper( el ).css({
11695 overflow: "hidden"
11696 });
11697
11698 if ( show ) {
11699 el.css( ref, positiveMotion ? (isNaN(distance) ? "-" + distance : -distance) : distance );
11700 }
11701
11702 // Animation
11703 animation[ ref ] = ( show ?
11704 ( positiveMotion ? "+=" : "-=") :
11705 ( positiveMotion ? "-=" : "+=")) +
11706 distance;
11707
11708 // Animate
11709 el.animate( animation, {
11710 queue: false,
11711 duration: o.duration,
11712 easing: o.easing,
11713 complete: function() {
11714 if ( mode === "hide" ) {
11715 el.hide();
11716 }
11717 $.effects.restore( el, props );
11718 $.effects.removeWrapper( el );
11719 done();
11720 }
11721 });
11722 };
11723
11724
11725 /*!
11726 * jQuery UI Effects Transfer 1.11.4
11727 * http://jqueryui.com
11728 *
11729 * Copyright jQuery Foundation and other contributors
11730 * Released under the MIT license.
11731 * http://jquery.org/license
11732 *
11733 * http://api.jqueryui.com/transfer-effect/
11734 */
11735
11736
11737 var effectTransfer = $.effects.effect.transfer = function( o, done ) {
11738 var elem = $( this ),
11739 target = $( o.to ),
11740 targetFixed = target.css( "position" ) === "fixed",
11741 body = $("body"),
11742 fixTop = targetFixed ? body.scrollTop() : 0,
11743 fixLeft = targetFixed ? body.scrollLeft() : 0,
11744 endPosition = target.offset(),
11745 animation = {
11746 top: endPosition.top - fixTop,
11747 left: endPosition.left - fixLeft,
11748 height: target.innerHeight(),
11749 width: target.innerWidth()
11750 },
11751 startPosition = elem.offset(),
11752 transfer = $( "<div class='ui-effects-transfer'></div>" )
11753 .appendTo( document.body )
11754 .addClass( o.className )
11755 .css({
11756 top: startPosition.top - fixTop,
11757 left: startPosition.left - fixLeft,
11758 height: elem.innerHeight(),
11759 width: elem.innerWidth(),
11760 position: targetFixed ? "fixed" : "absolute"
11761 })
11762 .animate( animation, o.duration, o.easing, function() {
11763 transfer.remove();
11764 done();
11765 });
11766 };
11767
11768
11769 /*!
11770 * jQuery UI Progressbar 1.11.4
11771 * http://jqueryui.com
11772 *
11773 * Copyright jQuery Foundation and other contributors
11774 * Released under the MIT license.
11775 * http://jquery.org/license
11776 *
11777 * http://api.jqueryui.com/progressbar/
11778 */
11779
11780
11781 var progressbar = $.widget( "ui.progressbar", {
11782 version: "1.11.4",
11783 options: {
11784 max: 100,
11785 value: 0,
11786
11787 change: null,
11788 complete: null
11789 },
11790
11791 min: 0,
11792
11793 _create: function() {
11794 // Constrain initial value
11795 this.oldValue = this.options.value = this._constrainedValue();
11796
11797 this.element
11798 .addClass( "ui-progressbar ui-widget ui-widget-content ui-corner-all" )
11799 .attr({
11800 // Only set static values, aria-valuenow and aria-valuemax are
11801 // set inside _refreshValue()
11802 role: "progressbar",
11803 "aria-valuemin": this.min
11804 });
11805
11806 this.valueDiv = $( "<div class='ui-progressbar-value ui-widget-header ui-corner-left'></div>" )
11807 .appendTo( this.element );
11808
11809 this._refreshValue();
11810 },
11811
11812 _destroy: function() {
11813 this.element
11814 .removeClass( "ui-progressbar ui-widget ui-widget-content ui-corner-all" )
11815 .removeAttr( "role" )
11816 .removeAttr( "aria-valuemin" )
11817 .removeAttr( "aria-valuemax" )
11818 .removeAttr( "aria-valuenow" );
11819
11820 this.valueDiv.remove();
11821 },
11822
11823 value: function( newValue ) {
11824 if ( newValue === undefined ) {
11825 return this.options.value;
11826 }
11827
11828 this.options.value = this._constrainedValue( newValue );
11829 this._refreshValue();
11830 },
11831
11832 _constrainedValue: function( newValue ) {
11833 if ( newValue === undefined ) {
11834 newValue = this.options.value;
11835 }
11836
11837 this.indeterminate = newValue === false;
11838
11839 // sanitize value
11840 if ( typeof newValue !== "number" ) {
11841 newValue = 0;
11842 }
11843
11844 return this.indeterminate ? false :
11845 Math.min( this.options.max, Math.max( this.min, newValue ) );
11846 },
11847
11848 _setOptions: function( options ) {
11849 // Ensure "value" option is set after other values (like max)
11850 var value = options.value;
11851 delete options.value;
11852
11853 this._super( options );
11854
11855 this.options.value = this._constrainedValue( value );
11856 this._refreshValue();
11857 },
11858
11859 _setOption: function( key, value ) {
11860 if ( key === "max" ) {
11861 // Don't allow a max less than min
11862 value = Math.max( this.min, value );
11863 }
11864 if ( key === "disabled" ) {
11865 this.element
11866 .toggleClass( "ui-state-disabled", !!value )
11867 .attr( "aria-disabled", value );
11868 }
11869 this._super( key, value );
11870 },
11871
11872 _percentage: function() {
11873 return this.indeterminate ? 100 : 100 * ( this.options.value - this.min ) / ( this.options.max - this.min );
11874 },
11875
11876 _refreshValue: function() {
11877 var value = this.options.value,
11878 percentage = this._percentage();
11879
11880 this.valueDiv
11881 .toggle( this.indeterminate || value > this.min )
11882 .toggleClass( "ui-corner-right", value === this.options.max )
11883 .width( percentage.toFixed(0) + "%" );
11884
11885 this.element.toggleClass( "ui-progressbar-indeterminate", this.indeterminate );
11886
11887 if ( this.indeterminate ) {
11888 this.element.removeAttr( "aria-valuenow" );
11889 if ( !this.overlayDiv ) {
11890 this.overlayDiv = $( "<div class='ui-progressbar-overlay'></div>" ).appendTo( this.valueDiv );
11891 }
11892 } else {
11893 this.element.attr({
11894 "aria-valuemax": this.options.max,
11895 "aria-valuenow": value
11896 });
11897 if ( this.overlayDiv ) {
11898 this.overlayDiv.remove();
11899 this.overlayDiv = null;
11900 }
11901 }
11902
11903 if ( this.oldValue !== value ) {
11904 this.oldValue = value;
11905 this._trigger( "change" );
11906 }
11907 if ( value === this.options.max ) {
11908 this._trigger( "complete" );
11909 }
11910 }
11911 });
11912
11913
11914 /*!
11915 * jQuery UI Selectable 1.11.4
11916 * http://jqueryui.com
11917 *
11918 * Copyright jQuery Foundation and other contributors
11919 * Released under the MIT license.
11920 * http://jquery.org/license
11921 *
11922 * http://api.jqueryui.com/selectable/
11923 */
11924
11925
11926 var selectable = $.widget("ui.selectable", $.ui.mouse, {
11927 version: "1.11.4",
11928 options: {
11929 appendTo: "body",
11930 autoRefresh: true,
11931 distance: 0,
11932 filter: "*",
11933 tolerance: "touch",
11934
11935 // callbacks
11936 selected: null,
11937 selecting: null,
11938 start: null,
11939 stop: null,
11940 unselected: null,
11941 unselecting: null
11942 },
11943 _create: function() {
11944 var selectees,
11945 that = this;
11946
11947 this.element.addClass("ui-selectable");
11948
11949 this.dragged = false;
11950
11951 // cache selectee children based on filter
11952 this.refresh = function() {
11953 selectees = $(that.options.filter, that.element[0]);
11954 selectees.addClass("ui-selectee");
11955 selectees.each(function() {
11956 var $this = $(this),
11957 pos = $this.offset();
11958 $.data(this, "selectable-item", {
11959 element: this,
11960 $element: $this,
11961 left: pos.left,
11962 top: pos.top,
11963 right: pos.left + $this.outerWidth(),
11964 bottom: pos.top + $this.outerHeight(),
11965 startselected: false,
11966 selected: $this.hasClass("ui-selected"),
11967 selecting: $this.hasClass("ui-selecting"),
11968 unselecting: $this.hasClass("ui-unselecting")
11969 });
11970 });
11971 };
11972 this.refresh();
11973
11974 this.selectees = selectees.addClass("ui-selectee");
11975
11976 this._mouseInit();
11977
11978 this.helper = $("<div class='ui-selectable-helper'></div>");
11979 },
11980
11981 _destroy: function() {
11982 this.selectees
11983 .removeClass("ui-selectee")
11984 .removeData("selectable-item");
11985 this.element
11986 .removeClass("ui-selectable ui-selectable-disabled");
11987 this._mouseDestroy();
11988 },
11989
11990 _mouseStart: function(event) {
11991 var that = this,
11992 options = this.options;
11993
11994 this.opos = [ event.pageX, event.pageY ];
11995
11996 if (this.options.disabled) {
11997 return;
11998 }
11999
12000 this.selectees = $(options.filter, this.element[0]);
12001
12002 this._trigger("start", event);
12003
12004 $(options.appendTo).append(this.helper);
12005 // position helper (lasso)
12006 this.helper.css({
12007 "left": event.pageX,
12008 "top": event.pageY,
12009 "width": 0,
12010 "height": 0
12011 });
12012
12013 if (options.autoRefresh) {
12014 this.refresh();
12015 }
12016
12017 this.selectees.filter(".ui-selected").each(function() {
12018 var selectee = $.data(this, "selectable-item");
12019 selectee.startselected = true;
12020 if (!event.metaKey && !event.ctrlKey) {
12021 selectee.$element.removeClass("ui-selected");
12022 selectee.selected = false;
12023 selectee.$element.addClass("ui-unselecting");
12024 selectee.unselecting = true;
12025 // selectable UNSELECTING callback
12026 that._trigger("unselecting", event, {
12027 unselecting: selectee.element
12028 });
12029 }
12030 });
12031
12032 $(event.target).parents().addBack().each(function() {
12033 var doSelect,
12034 selectee = $.data(this, "selectable-item");
12035 if (selectee) {
12036 doSelect = (!event.metaKey && !event.ctrlKey) || !selectee.$element.hasClass("ui-selected");
12037 selectee.$element
12038 .removeClass(doSelect ? "ui-unselecting" : "ui-selected")
12039 .addClass(doSelect ? "ui-selecting" : "ui-unselecting");
12040 selectee.unselecting = !doSelect;
12041 selectee.selecting = doSelect;
12042 selectee.selected = doSelect;
12043 // selectable (UN)SELECTING callback
12044 if (doSelect) {
12045 that._trigger("selecting", event, {
12046 selecting: selectee.element
12047 });
12048 } else {
12049 that._trigger("unselecting", event, {
12050 unselecting: selectee.element
12051 });
12052 }
12053 return false;
12054 }
12055 });
12056
12057 },
12058
12059 _mouseDrag: function(event) {
12060
12061 this.dragged = true;
12062
12063 if (this.options.disabled) {
12064 return;
12065 }
12066
12067 var tmp,
12068 that = this,
12069 options = this.options,
12070 x1 = this.opos[0],
12071 y1 = this.opos[1],
12072 x2 = event.pageX,
12073 y2 = event.pageY;
12074
12075 if (x1 > x2) { tmp = x2; x2 = x1; x1 = tmp; }
12076 if (y1 > y2) { tmp = y2; y2 = y1; y1 = tmp; }
12077 this.helper.css({ left: x1, top: y1, width: x2 - x1, height: y2 - y1 });
12078
12079 this.selectees.each(function() {
12080 var selectee = $.data(this, "selectable-item"),
12081 hit = false;
12082
12083 //prevent helper from being selected if appendTo: selectable
12084 if (!selectee || selectee.element === that.element[0]) {
12085 return;
12086 }
12087
12088 if (options.tolerance === "touch") {
12089 hit = ( !(selectee.left > x2 || selectee.right < x1 || selectee.top > y2 || selectee.bottom < y1) );
12090 } else if (options.tolerance === "fit") {
12091 hit = (selectee.left > x1 && selectee.right < x2 && selectee.top > y1 && selectee.bottom < y2);
12092 }
12093
12094 if (hit) {
12095 // SELECT
12096 if (selectee.selected) {
12097 selectee.$element.removeClass("ui-selected");
12098 selectee.selected = false;
12099 }
12100 if (selectee.unselecting) {
12101 selectee.$element.removeClass("ui-unselecting");
12102 selectee.unselecting = false;
12103 }
12104 if (!selectee.selecting) {
12105 selectee.$element.addClass("ui-selecting");
12106 selectee.selecting = true;
12107 // selectable SELECTING callback
12108 that._trigger("selecting", event, {
12109 selecting: selectee.element
12110 });
12111 }
12112 } else {
12113 // UNSELECT
12114 if (selectee.selecting) {
12115 if ((event.metaKey || event.ctrlKey) && selectee.startselected) {
12116 selectee.$element.removeClass("ui-selecting");
12117 selectee.selecting = false;
12118 selectee.$element.addClass("ui-selected");
12119 selectee.selected = true;
12120 } else {
12121 selectee.$element.removeClass("ui-selecting");
12122 selectee.selecting = false;
12123 if (selectee.startselected) {
12124 selectee.$element.addClass("ui-unselecting");
12125 selectee.unselecting = true;
12126 }
12127 // selectable UNSELECTING callback
12128 that._trigger("unselecting", event, {
12129 unselecting: selectee.element
12130 });
12131 }
12132 }
12133 if (selectee.selected) {
12134 if (!event.metaKey && !event.ctrlKey && !selectee.startselected) {
12135 selectee.$element.removeClass("ui-selected");
12136 selectee.selected = false;
12137
12138 selectee.$element.addClass("ui-unselecting");
12139 selectee.unselecting = true;
12140 // selectable UNSELECTING callback
12141 that._trigger("unselecting", event, {
12142 unselecting: selectee.element
12143 });
12144 }
12145 }
12146 }
12147 });
12148
12149 return false;
12150 },
12151
12152 _mouseStop: function(event) {
12153 var that = this;
12154
12155 this.dragged = false;
12156
12157 $(".ui-unselecting", this.element[0]).each(function() {
12158 var selectee = $.data(this, "selectable-item");
12159 selectee.$element.removeClass("ui-unselecting");
12160 selectee.unselecting = false;
12161 selectee.startselected = false;
12162 that._trigger("unselected", event, {
12163 unselected: selectee.element
12164 });
12165 });
12166 $(".ui-selecting", this.element[0]).each(function() {
12167 var selectee = $.data(this, "selectable-item");
12168 selectee.$element.removeClass("ui-selecting").addClass("ui-selected");
12169 selectee.selecting = false;
12170 selectee.selected = true;
12171 selectee.startselected = true;
12172 that._trigger("selected", event, {
12173 selected: selectee.element
12174 });
12175 });
12176 this._trigger("stop", event);
12177
12178 this.helper.remove();
12179
12180 return false;
12181 }
12182
12183 });
12184
12185
12186 /*!
12187 * jQuery UI Selectmenu 1.11.4
12188 * http://jqueryui.com
12189 *
12190 * Copyright jQuery Foundation and other contributors
12191 * Released under the MIT license.
12192 * http://jquery.org/license
12193 *
12194 * http://api.jqueryui.com/selectmenu
12195 */
12196
12197
12198 var selectmenu = $.widget( "ui.selectmenu", {
12199 version: "1.11.4",
12200 defaultElement: "<select>",
12201 options: {
12202 appendTo: null,
12203 disabled: null,
12204 icons: {
12205 button: "ui-icon-triangle-1-s"
12206 },
12207 position: {
12208 my: "left top",
12209 at: "left bottom",
12210 collision: "none"
12211 },
12212 width: null,
12213
12214 // callbacks
12215 change: null,
12216 close: null,
12217 focus: null,
12218 open: null,
12219 select: null
12220 },
12221
12222 _create: function() {
12223 var selectmenuId = this.element.uniqueId().attr( "id" );
12224 this.ids = {
12225 element: selectmenuId,
12226 button: selectmenuId + "-button",
12227 menu: selectmenuId + "-menu"
12228 };
12229
12230 this._drawButton();
12231 this._drawMenu();
12232
12233 if ( this.options.disabled ) {
12234 this.disable();
12235 }
12236 },
12237
12238 _drawButton: function() {
12239 var that = this;
12240
12241 // Associate existing label with the new button
12242 this.label = $( "label[for='" + this.ids.element + "']" ).attr( "for", this.ids.button );
12243 this._on( this.label, {
12244 click: function( event ) {
12245 this.button.focus();
12246 event.preventDefault();
12247 }
12248 });
12249
12250 // Hide original select element
12251 this.element.hide();
12252
12253 // Create button
12254 this.button = $( "<span>", {
12255 "class": "ui-selectmenu-button ui-widget ui-state-default ui-corner-all",
12256 tabindex: this.options.disabled ? -1 : 0,
12257 id: this.ids.button,
12258 role: "combobox",
12259 "aria-expanded": "false",
12260 "aria-autocomplete": "list",
12261 "aria-owns": this.ids.menu,
12262 "aria-haspopup": "true"
12263 })
12264 .insertAfter( this.element );
12265
12266 $( "<span>", {
12267 "class": "ui-icon " + this.options.icons.button
12268 })
12269 .prependTo( this.button );
12270
12271 this.buttonText = $( "<span>", {
12272 "class": "ui-selectmenu-text"
12273 })
12274 .appendTo( this.button );
12275
12276 this._setText( this.buttonText, this.element.find( "option:selected" ).text() );
12277 this._resizeButton();
12278
12279 this._on( this.button, this._buttonEvents );
12280 this.button.one( "focusin", function() {
12281
12282 // Delay rendering the menu items until the button receives focus.
12283 // The menu may have already been rendered via a programmatic open.
12284 if ( !that.menuItems ) {
12285 that._refreshMenu();
12286 }
12287 });
12288 this._hoverable( this.button );
12289 this._focusable( this.button );
12290 },
12291
12292 _drawMenu: function() {
12293 var that = this;
12294
12295 // Create menu
12296 this.menu = $( "<ul>", {
12297 "aria-hidden": "true",
12298 "aria-labelledby": this.ids.button,
12299 id: this.ids.menu
12300 });
12301
12302 // Wrap menu
12303 this.menuWrap = $( "<div>", {
12304 "class": "ui-selectmenu-menu ui-front"
12305 })
12306 .append( this.menu )
12307 .appendTo( this._appendTo() );
12308
12309 // Initialize menu widget
12310 this.menuInstance = this.menu
12311 .menu({
12312 role: "listbox",
12313 select: function( event, ui ) {
12314 event.preventDefault();
12315
12316 // support: IE8
12317 // If the item was selected via a click, the text selection
12318 // will be destroyed in IE
12319 that._setSelection();
12320
12321 that._select( ui.item.data( "ui-selectmenu-item" ), event );
12322 },
12323 focus: function( event, ui ) {
12324 var item = ui.item.data( "ui-selectmenu-item" );
12325
12326 // Prevent inital focus from firing and check if its a newly focused item
12327 if ( that.focusIndex != null && item.index !== that.focusIndex ) {
12328 that._trigger( "focus", event, { item: item } );
12329 if ( !that.isOpen ) {
12330 that._select( item, event );
12331 }
12332 }
12333 that.focusIndex = item.index;
12334
12335 that.button.attr( "aria-activedescendant",
12336 that.menuItems.eq( item.index ).attr( "id" ) );
12337 }
12338 })
12339 .menu( "instance" );
12340
12341 // Adjust menu styles to dropdown
12342 this.menu
12343 .addClass( "ui-corner-bottom" )
12344 .removeClass( "ui-corner-all" );
12345
12346 // Don't close the menu on mouseleave
12347 this.menuInstance._off( this.menu, "mouseleave" );
12348
12349 // Cancel the menu's collapseAll on document click
12350 this.menuInstance._closeOnDocumentClick = function() {
12351 return false;
12352 };
12353
12354 // Selects often contain empty items, but never contain dividers
12355 this.menuInstance._isDivider = function() {
12356 return false;
12357 };
12358 },
12359
12360 refresh: function() {
12361 this._refreshMenu();
12362 this._setText( this.buttonText, this._getSelectedItem().text() );
12363 if ( !this.options.width ) {
12364 this._resizeButton();
12365 }
12366 },
12367
12368 _refreshMenu: function() {
12369 this.menu.empty();
12370
12371 var item,
12372 options = this.element.find( "option" );
12373
12374 if ( !options.length ) {
12375 return;
12376 }
12377
12378 this._parseOptions( options );
12379 this._renderMenu( this.menu, this.items );
12380
12381 this.menuInstance.refresh();
12382 this.menuItems = this.menu.find( "li" ).not( ".ui-selectmenu-optgroup" );
12383
12384 item = this._getSelectedItem();
12385
12386 // Update the menu to have the correct item focused
12387 this.menuInstance.focus( null, item );
12388 this._setAria( item.data( "ui-selectmenu-item" ) );
12389
12390 // Set disabled state
12391 this._setOption( "disabled", this.element.prop( "disabled" ) );
12392 },
12393
12394 open: function( event ) {
12395 if ( this.options.disabled ) {
12396 return;
12397 }
12398
12399 // If this is the first time the menu is being opened, render the items
12400 if ( !this.menuItems ) {
12401 this._refreshMenu();
12402 } else {
12403
12404 // Menu clears focus on close, reset focus to selected item
12405 this.menu.find( ".ui-state-focus" ).removeClass( "ui-state-focus" );
12406 this.menuInstance.focus( null, this._getSelectedItem() );
12407 }
12408
12409 this.isOpen = true;
12410 this._toggleAttr();
12411 this._resizeMenu();
12412 this._position();
12413
12414 this._on( this.document, this._documentClick );
12415
12416 this._trigger( "open", event );
12417 },
12418
12419 _position: function() {
12420 this.menuWrap.position( $.extend( { of: this.button }, this.options.position ) );
12421 },
12422
12423 close: function( event ) {
12424 if ( !this.isOpen ) {
12425 return;
12426 }
12427
12428 this.isOpen = false;
12429 this._toggleAttr();
12430
12431 this.range = null;
12432 this._off( this.document );
12433
12434 this._trigger( "close", event );
12435 },
12436
12437 widget: function() {
12438 return this.button;
12439 },
12440
12441 menuWidget: function() {
12442 return this.menu;
12443 },
12444
12445 _renderMenu: function( ul, items ) {
12446 var that = this,
12447 currentOptgroup = "";
12448
12449 $.each( items, function( index, item ) {
12450 if ( item.optgroup !== currentOptgroup ) {
12451 $( "<li>", {
12452 "class": "ui-selectmenu-optgroup ui-menu-divider" +
12453 ( item.element.parent( "optgroup" ).prop( "disabled" ) ?
12454 " ui-state-disabled" :
12455 "" ),
12456 text: item.optgroup
12457 })
12458 .appendTo( ul );
12459
12460 currentOptgroup = item.optgroup;
12461 }
12462
12463 that._renderItemData( ul, item );
12464 });
12465 },
12466
12467 _renderItemData: function( ul, item ) {
12468 return this._renderItem( ul, item ).data( "ui-selectmenu-item", item );
12469 },
12470
12471 _renderItem: function( ul, item ) {
12472 var li = $( "<li>" );
12473
12474 if ( item.disabled ) {
12475 li.addClass( "ui-state-disabled" );
12476 }
12477 this._setText( li, item.label );
12478
12479 return li.appendTo( ul );
12480 },
12481
12482 _setText: function( element, value ) {
12483 if ( value ) {
12484 element.text( value );
12485 } else {
12486 element.html( " " );
12487 }
12488 },
12489
12490 _move: function( direction, event ) {
12491 var item, next,
12492 filter = ".ui-menu-item";
12493
12494 if ( this.isOpen ) {
12495 item = this.menuItems.eq( this.focusIndex );
12496 } else {
12497 item = this.menuItems.eq( this.element[ 0 ].selectedIndex );
12498 filter += ":not(.ui-state-disabled)";
12499 }
12500
12501 if ( direction === "first" || direction === "last" ) {
12502 next = item[ direction === "first" ? "prevAll" : "nextAll" ]( filter ).eq( -1 );
12503 } else {
12504 next = item[ direction + "All" ]( filter ).eq( 0 );
12505 }
12506
12507 if ( next.length ) {
12508 this.menuInstance.focus( event, next );
12509 }
12510 },
12511
12512 _getSelectedItem: function() {
12513 return this.menuItems.eq( this.element[ 0 ].selectedIndex );
12514 },
12515
12516 _toggle: function( event ) {
12517 this[ this.isOpen ? "close" : "open" ]( event );
12518 },
12519
12520 _setSelection: function() {
12521 var selection;
12522
12523 if ( !this.range ) {
12524 return;
12525 }
12526
12527 if ( window.getSelection ) {
12528 selection = window.getSelection();
12529 selection.removeAllRanges();
12530 selection.addRange( this.range );
12531
12532 // support: IE8
12533 } else {
12534 this.range.select();
12535 }
12536
12537 // support: IE
12538 // Setting the text selection kills the button focus in IE, but
12539 // restoring the focus doesn't kill the selection.
12540 this.button.focus();
12541 },
12542
12543 _documentClick: {
12544 mousedown: function( event ) {
12545 if ( !this.isOpen ) {
12546 return;
12547 }
12548
12549 if ( !$( event.target ).closest( ".ui-selectmenu-menu, #" + this.ids.button ).length ) {
12550 this.close( event );
12551 }
12552 }
12553 },
12554
12555 _buttonEvents: {
12556
12557 // Prevent text selection from being reset when interacting with the selectmenu (#10144)
12558 mousedown: function() {
12559 var selection;
12560
12561 if ( window.getSelection ) {
12562 selection = window.getSelection();
12563 if ( selection.rangeCount ) {
12564 this.range = selection.getRangeAt( 0 );
12565 }
12566
12567 // support: IE8
12568 } else {
12569 this.range = document.selection.createRange();
12570 }
12571 },
12572
12573 click: function( event ) {
12574 this._setSelection();
12575 this._toggle( event );
12576 },
12577
12578 keydown: function( event ) {
12579 var preventDefault = true;
12580 switch ( event.keyCode ) {
12581 case $.ui.keyCode.TAB:
12582 case $.ui.keyCode.ESCAPE:
12583 this.close( event );
12584 preventDefault = false;
12585 break;
12586 case $.ui.keyCode.ENTER:
12587 if ( this.isOpen ) {
12588 this._selectFocusedItem( event );
12589 }
12590 break;
12591 case $.ui.keyCode.UP:
12592 if ( event.altKey ) {
12593 this._toggle( event );
12594 } else {
12595 this._move( "prev", event );
12596 }
12597 break;
12598 case $.ui.keyCode.DOWN:
12599 if ( event.altKey ) {
12600 this._toggle( event );
12601 } else {
12602 this._move( "next", event );
12603 }
12604 break;
12605 case $.ui.keyCode.SPACE:
12606 if ( this.isOpen ) {
12607 this._selectFocusedItem( event );
12608 } else {
12609 this._toggle( event );
12610 }
12611 break;
12612 case $.ui.keyCode.LEFT:
12613 this._move( "prev", event );
12614 break;
12615 case $.ui.keyCode.RIGHT:
12616 this._move( "next", event );
12617 break;
12618 case $.ui.keyCode.HOME:
12619 case $.ui.keyCode.PAGE_UP:
12620 this._move( "first", event );
12621 break;
12622 case $.ui.keyCode.END:
12623 case $.ui.keyCode.PAGE_DOWN:
12624 this._move( "last", event );
12625 break;
12626 default:
12627 this.menu.trigger( event );
12628 preventDefault = false;
12629 }
12630
12631 if ( preventDefault ) {
12632 event.preventDefault();
12633 }
12634 }
12635 },
12636
12637 _selectFocusedItem: function( event ) {
12638 var item = this.menuItems.eq( this.focusIndex );
12639 if ( !item.hasClass( "ui-state-disabled" ) ) {
12640 this._select( item.data( "ui-selectmenu-item" ), event );
12641 }
12642 },
12643
12644 _select: function( item, event ) {
12645 var oldIndex = this.element[ 0 ].selectedIndex;
12646
12647 // Change native select element
12648 this.element[ 0 ].selectedIndex = item.index;
12649 this._setText( this.buttonText, item.label );
12650 this._setAria( item );
12651 this._trigger( "select", event, { item: item } );
12652
12653 if ( item.index !== oldIndex ) {
12654 this._trigger( "change", event, { item: item } );
12655 }
12656
12657 this.close( event );
12658 },
12659
12660 _setAria: function( item ) {
12661 var id = this.menuItems.eq( item.index ).attr( "id" );
12662
12663 this.button.attr({
12664 "aria-labelledby": id,
12665 "aria-activedescendant": id
12666 });
12667 this.menu.attr( "aria-activedescendant", id );
12668 },
12669
12670 _setOption: function( key, value ) {
12671 if ( key === "icons" ) {
12672 this.button.find( "span.ui-icon" )
12673 .removeClass( this.options.icons.button )
12674 .addClass( value.button );
12675 }
12676
12677 this._super( key, value );
12678
12679 if ( key === "appendTo" ) {
12680 this.menuWrap.appendTo( this._appendTo() );
12681 }
12682
12683 if ( key === "disabled" ) {
12684 this.menuInstance.option( "disabled", value );
12685 this.button
12686 .toggleClass( "ui-state-disabled", value )
12687 .attr( "aria-disabled", value );
12688
12689 this.element.prop( "disabled", value );
12690 if ( value ) {
12691 this.button.attr( "tabindex", -1 );
12692 this.close();
12693 } else {
12694 this.button.attr( "tabindex", 0 );
12695 }
12696 }
12697
12698 if ( key === "width" ) {
12699 this._resizeButton();
12700 }
12701 },
12702
12703 _appendTo: function() {
12704 var element = this.options.appendTo;
12705
12706 if ( element ) {
12707 element = element.jquery || element.nodeType ?
12708 $( element ) :
12709 this.document.find( element ).eq( 0 );
12710 }
12711
12712 if ( !element || !element[ 0 ] ) {
12713 element = this.element.closest( ".ui-front" );
12714 }
12715
12716 if ( !element.length ) {
12717 element = this.document[ 0 ].body;
12718 }
12719
12720 return element;
12721 },
12722
12723 _toggleAttr: function() {
12724 this.button
12725 .toggleClass( "ui-corner-top", this.isOpen )
12726 .toggleClass( "ui-corner-all", !this.isOpen )
12727 .attr( "aria-expanded", this.isOpen );
12728 this.menuWrap.toggleClass( "ui-selectmenu-open", this.isOpen );
12729 this.menu.attr( "aria-hidden", !this.isOpen );
12730 },
12731
12732 _resizeButton: function() {
12733 var width = this.options.width;
12734
12735 if ( !width ) {
12736 width = this.element.show().outerWidth();
12737 this.element.hide();
12738 }
12739
12740 this.button.outerWidth( width );
12741 },
12742
12743 _resizeMenu: function() {
12744 this.menu.outerWidth( Math.max(
12745 this.button.outerWidth(),
12746
12747 // support: IE10
12748 // IE10 wraps long text (possibly a rounding bug)
12749 // so we add 1px to avoid the wrapping
12750 this.menu.width( "" ).outerWidth() + 1
12751 ) );
12752 },
12753
12754 _getCreateOptions: function() {
12755 return { disabled: this.element.prop( "disabled" ) };
12756 },
12757
12758 _parseOptions: function( options ) {
12759 var data = [];
12760 options.each(function( index, item ) {
12761 var option = $( item ),
12762 optgroup = option.parent( "optgroup" );
12763 data.push({
12764 element: option,
12765 index: index,
12766 value: option.val(),
12767 label: option.text(),
12768 optgroup: optgroup.attr( "label" ) || "",
12769 disabled: optgroup.prop( "disabled" ) || option.prop( "disabled" )
12770 });
12771 });
12772 this.items = data;
12773 },
12774
12775 _destroy: function() {
12776 this.menuWrap.remove();
12777 this.button.remove();
12778 this.element.show();
12779 this.element.removeUniqueId();
12780 this.label.attr( "for", this.ids.element );
12781 }
12782 });
12783
12784
12785 /*!
12786 * jQuery UI Slider 1.11.4
12787 * http://jqueryui.com
12788 *
12789 * Copyright jQuery Foundation and other contributors
12790 * Released under the MIT license.
12791 * http://jquery.org/license
12792 *
12793 * http://api.jqueryui.com/slider/
12794 */
12795
12796
12797 var slider = $.widget( "ui.slider", $.ui.mouse, {
12798 version: "1.11.4",
12799 widgetEventPrefix: "slide",
12800
12801 options: {
12802 animate: false,
12803 distance: 0,
12804 max: 100,
12805 min: 0,
12806 orientation: "horizontal",
12807 range: false,
12808 step: 1,
12809 value: 0,
12810 values: null,
12811
12812 // callbacks
12813 change: null,
12814 slide: null,
12815 start: null,
12816 stop: null
12817 },
12818
12819 // number of pages in a slider
12820 // (how many times can you page up/down to go through the whole range)
12821 numPages: 5,
12822
12823 _create: function() {
12824 this._keySliding = false;
12825 this._mouseSliding = false;
12826 this._animateOff = true;
12827 this._handleIndex = null;
12828 this._detectOrientation();
12829 this._mouseInit();
12830 this._calculateNewMax();
12831
12832 this.element
12833 .addClass( "ui-slider" +
12834 " ui-slider-" + this.orientation +
12835 " ui-widget" +
12836 " ui-widget-content" +
12837 " ui-corner-all");
12838
12839 this._refresh();
12840 this._setOption( "disabled", this.options.disabled );
12841
12842 this._animateOff = false;
12843 },
12844
12845 _refresh: function() {
12846 this._createRange();
12847 this._createHandles();
12848 this._setupEvents();
12849 this._refreshValue();
12850 },
12851
12852 _createHandles: function() {
12853 var i, handleCount,
12854 options = this.options,
12855 existingHandles = this.element.find( ".ui-slider-handle" ).addClass( "ui-state-default ui-corner-all" ),
12856 handle = "<span class='ui-slider-handle ui-state-default ui-corner-all' tabindex='0'></span>",
12857 handles = [];
12858
12859 handleCount = ( options.values && options.values.length ) || 1;
12860
12861 if ( existingHandles.length > handleCount ) {
12862 existingHandles.slice( handleCount ).remove();
12863 existingHandles = existingHandles.slice( 0, handleCount );
12864 }
12865
12866 for ( i = existingHandles.length; i < handleCount; i++ ) {
12867 handles.push( handle );
12868 }
12869
12870 this.handles = existingHandles.add( $( handles.join( "" ) ).appendTo( this.element ) );
12871
12872 this.handle = this.handles.eq( 0 );
12873
12874 this.handles.each(function( i ) {
12875 $( this ).data( "ui-slider-handle-index", i );
12876 });
12877 },
12878
12879 _createRange: function() {
12880 var options = this.options,
12881 classes = "";
12882
12883 if ( options.range ) {
12884 if ( options.range === true ) {
12885 if ( !options.values ) {
12886 options.values = [ this._valueMin(), this._valueMin() ];
12887 } else if ( options.values.length && options.values.length !== 2 ) {
12888 options.values = [ options.values[0], options.values[0] ];
12889 } else if ( $.isArray( options.values ) ) {
12890 options.values = options.values.slice(0);
12891 }
12892 }
12893
12894 if ( !this.range || !this.range.length ) {
12895 this.range = $( "<div></div>" )
12896 .appendTo( this.element );
12897
12898 classes = "ui-slider-range" +
12899 // note: this isn't the most fittingly semantic framework class for this element,
12900 // but worked best visually with a variety of themes
12901 " ui-widget-header ui-corner-all";
12902 } else {
12903 this.range.removeClass( "ui-slider-range-min ui-slider-range-max" )
12904 // Handle range switching from true to min/max
12905 .css({
12906 "left": "",
12907 "bottom": ""
12908 });
12909 }
12910
12911 this.range.addClass( classes +
12912 ( ( options.range === "min" || options.range === "max" ) ? " ui-slider-range-" + options.range : "" ) );
12913 } else {
12914 if ( this.range ) {
12915 this.range.remove();
12916 }
12917 this.range = null;
12918 }
12919 },
12920
12921 _setupEvents: function() {
12922 this._off( this.handles );
12923 this._on( this.handles, this._handleEvents );
12924 this._hoverable( this.handles );
12925 this._focusable( this.handles );
12926 },
12927
12928 _destroy: function() {
12929 this.handles.remove();
12930 if ( this.range ) {
12931 this.range.remove();
12932 }
12933
12934 this.element
12935 .removeClass( "ui-slider" +
12936 " ui-slider-horizontal" +
12937 " ui-slider-vertical" +
12938 " ui-widget" +
12939 " ui-widget-content" +
12940 " ui-corner-all" );
12941
12942 this._mouseDestroy();
12943 },
12944
12945 _mouseCapture: function( event ) {
12946 var position, normValue, distance, closestHandle, index, allowed, offset, mouseOverHandle,
12947 that = this,
12948 o = this.options;
12949
12950 if ( o.disabled ) {
12951 return false;
12952 }
12953
12954 this.elementSize = {
12955 width: this.element.outerWidth(),
12956 height: this.element.outerHeight()
12957 };
12958 this.elementOffset = this.element.offset();
12959
12960 position = { x: event.pageX, y: event.pageY };
12961 normValue = this._normValueFromMouse( position );
12962 distance = this._valueMax() - this._valueMin() + 1;
12963 this.handles.each(function( i ) {
12964 var thisDistance = Math.abs( normValue - that.values(i) );
12965 if (( distance > thisDistance ) ||
12966 ( distance === thisDistance &&
12967 (i === that._lastChangedValue || that.values(i) === o.min ))) {
12968 distance = thisDistance;
12969 closestHandle = $( this );
12970 index = i;
12971 }
12972 });
12973
12974 allowed = this._start( event, index );
12975 if ( allowed === false ) {
12976 return false;
12977 }
12978 this._mouseSliding = true;
12979
12980 this._handleIndex = index;
12981
12982 closestHandle
12983 .addClass( "ui-state-active" )
12984 .focus();
12985
12986 offset = closestHandle.offset();
12987 mouseOverHandle = !$( event.target ).parents().addBack().is( ".ui-slider-handle" );
12988 this._clickOffset = mouseOverHandle ? { left: 0, top: 0 } : {
12989 left: event.pageX - offset.left - ( closestHandle.width() / 2 ),
12990 top: event.pageY - offset.top -
12991 ( closestHandle.height() / 2 ) -
12992 ( parseInt( closestHandle.css("borderTopWidth"), 10 ) || 0 ) -
12993 ( parseInt( closestHandle.css("borderBottomWidth"), 10 ) || 0) +
12994 ( parseInt( closestHandle.css("marginTop"), 10 ) || 0)
12995 };
12996
12997 if ( !this.handles.hasClass( "ui-state-hover" ) ) {
12998 this._slide( event, index, normValue );
12999 }
13000 this._animateOff = true;
13001 return true;
13002 },
13003
13004 _mouseStart: function() {
13005 return true;
13006 },
13007
13008 _mouseDrag: function( event ) {
13009 var position = { x: event.pageX, y: event.pageY },
13010 normValue = this._normValueFromMouse( position );
13011
13012 this._slide( event, this._handleIndex, normValue );
13013
13014 return false;
13015 },
13016
13017 _mouseStop: function( event ) {
13018 this.handles.removeClass( "ui-state-active" );
13019 this._mouseSliding = false;
13020
13021 this._stop( event, this._handleIndex );
13022 this._change( event, this._handleIndex );
13023
13024 this._handleIndex = null;
13025 this._clickOffset = null;
13026 this._animateOff = false;
13027
13028 return false;
13029 },
13030
13031 _detectOrientation: function() {
13032 this.orientation = ( this.options.orientation === "vertical" ) ? "vertical" : "horizontal";
13033 },
13034
13035 _normValueFromMouse: function( position ) {
13036 var pixelTotal,
13037 pixelMouse,
13038 percentMouse,
13039 valueTotal,
13040 valueMouse;
13041
13042 if ( this.orientation === "horizontal" ) {
13043 pixelTotal = this.elementSize.width;
13044 pixelMouse = position.x - this.elementOffset.left - ( this._clickOffset ? this._clickOffset.left : 0 );
13045 } else {
13046 pixelTotal = this.elementSize.height;
13047 pixelMouse = position.y - this.elementOffset.top - ( this._clickOffset ? this._clickOffset.top : 0 );
13048 }
13049
13050 percentMouse = ( pixelMouse / pixelTotal );
13051 if ( percentMouse > 1 ) {
13052 percentMouse = 1;
13053 }
13054 if ( percentMouse < 0 ) {
13055 percentMouse = 0;
13056 }
13057 if ( this.orientation === "vertical" ) {
13058 percentMouse = 1 - percentMouse;
13059 }
13060
13061 valueTotal = this._valueMax() - this._valueMin();
13062 valueMouse = this._valueMin() + percentMouse * valueTotal;
13063
13064 return this._trimAlignValue( valueMouse );
13065 },
13066
13067 _start: function( event, index ) {
13068 var uiHash = {
13069 handle: this.handles[ index ],
13070 value: this.value()
13071 };
13072 if ( this.options.values && this.options.values.length ) {
13073 uiHash.value = this.values( index );
13074 uiHash.values = this.values();
13075 }
13076 return this._trigger( "start", event, uiHash );
13077 },
13078
13079 _slide: function( event, index, newVal ) {
13080 var otherVal,
13081 newValues,
13082 allowed;
13083
13084 if ( this.options.values && this.options.values.length ) {
13085 otherVal = this.values( index ? 0 : 1 );
13086
13087 if ( ( this.options.values.length === 2 && this.options.range === true ) &&
13088 ( ( index === 0 && newVal > otherVal) || ( index === 1 && newVal < otherVal ) )
13089 ) {
13090 newVal = otherVal;
13091 }
13092
13093 if ( newVal !== this.values( index ) ) {
13094 newValues = this.values();
13095 newValues[ index ] = newVal;
13096 // A slide can be canceled by returning false from the slide callback
13097 allowed = this._trigger( "slide", event, {
13098 handle: this.handles[ index ],
13099 value: newVal,
13100 values: newValues
13101 } );
13102 otherVal = this.values( index ? 0 : 1 );
13103 if ( allowed !== false ) {
13104 this.values( index, newVal );
13105 }
13106 }
13107 } else {
13108 if ( newVal !== this.value() ) {
13109 // A slide can be canceled by returning false from the slide callback
13110 allowed = this._trigger( "slide", event, {
13111 handle: this.handles[ index ],
13112 value: newVal
13113 } );
13114 if ( allowed !== false ) {
13115 this.value( newVal );
13116 }
13117 }
13118 }
13119 },
13120
13121 _stop: function( event, index ) {
13122 var uiHash = {
13123 handle: this.handles[ index ],
13124 value: this.value()
13125 };
13126 if ( this.options.values && this.options.values.length ) {
13127 uiHash.value = this.values( index );
13128 uiHash.values = this.values();
13129 }
13130
13131 this._trigger( "stop", event, uiHash );
13132 },
13133
13134 _change: function( event, index ) {
13135 if ( !this._keySliding && !this._mouseSliding ) {
13136 var uiHash = {
13137 handle: this.handles[ index ],
13138 value: this.value()
13139 };
13140 if ( this.options.values && this.options.values.length ) {
13141 uiHash.value = this.values( index );
13142 uiHash.values = this.values();
13143 }
13144
13145 //store the last changed value index for reference when handles overlap
13146 this._lastChangedValue = index;
13147
13148 this._trigger( "change", event, uiHash );
13149 }
13150 },
13151
13152 value: function( newValue ) {
13153 if ( arguments.length ) {
13154 this.options.value = this._trimAlignValue( newValue );
13155 this._refreshValue();
13156 this._change( null, 0 );
13157 return;
13158 }
13159
13160 return this._value();
13161 },
13162
13163 values: function( index, newValue ) {
13164 var vals,
13165 newValues,
13166 i;
13167
13168 if ( arguments.length > 1 ) {
13169 this.options.values[ index ] = this._trimAlignValue( newValue );
13170 this._refreshValue();
13171 this._change( null, index );
13172 return;
13173 }
13174
13175 if ( arguments.length ) {
13176 if ( $.isArray( arguments[ 0 ] ) ) {
13177 vals = this.options.values;
13178 newValues = arguments[ 0 ];
13179 for ( i = 0; i < vals.length; i += 1 ) {
13180 vals[ i ] = this._trimAlignValue( newValues[ i ] );
13181 this._change( null, i );
13182 }
13183 this._refreshValue();
13184 } else {
13185 if ( this.options.values && this.options.values.length ) {
13186 return this._values( index );
13187 } else {
13188 return this.value();
13189 }
13190 }
13191 } else {
13192 return this._values();
13193 }
13194 },
13195
13196 _setOption: function( key, value ) {
13197 var i,
13198 valsLength = 0;
13199
13200 if ( key === "range" && this.options.range === true ) {
13201 if ( value === "min" ) {
13202 this.options.value = this._values( 0 );
13203 this.options.values = null;
13204 } else if ( value === "max" ) {
13205 this.options.value = this._values( this.options.values.length - 1 );
13206 this.options.values = null;
13207 }
13208 }
13209
13210 if ( $.isArray( this.options.values ) ) {
13211 valsLength = this.options.values.length;
13212 }
13213
13214 if ( key === "disabled" ) {
13215 this.element.toggleClass( "ui-state-disabled", !!value );
13216 }
13217
13218 this._super( key, value );
13219
13220 switch ( key ) {
13221 case "orientation":
13222 this._detectOrientation();
13223 this.element
13224 .removeClass( "ui-slider-horizontal ui-slider-vertical" )
13225 .addClass( "ui-slider-" + this.orientation );
13226 this._refreshValue();
13227
13228 // Reset positioning from previous orientation
13229 this.handles.css( value === "horizontal" ? "bottom" : "left", "" );
13230 break;
13231 case "value":
13232 this._animateOff = true;
13233 this._refreshValue();
13234 this._change( null, 0 );
13235 this._animateOff = false;
13236 break;
13237 case "values":
13238 this._animateOff = true;
13239 this._refreshValue();
13240 for ( i = 0; i < valsLength; i += 1 ) {
13241 this._change( null, i );
13242 }
13243 this._animateOff = false;
13244 break;
13245 case "step":
13246 case "min":
13247 case "max":
13248 this._animateOff = true;
13249 this._calculateNewMax();
13250 this._refreshValue();
13251 this._animateOff = false;
13252 break;
13253 case "range":
13254 this._animateOff = true;
13255 this._refresh();
13256 this._animateOff = false;
13257 break;
13258 }
13259 },
13260
13261 //internal value getter
13262 // _value() returns value trimmed by min and max, aligned by step
13263 _value: function() {
13264 var val = this.options.value;
13265 val = this._trimAlignValue( val );
13266
13267 return val;
13268 },
13269
13270 //internal values getter
13271 // _values() returns array of values trimmed by min and max, aligned by step
13272 // _values( index ) returns single value trimmed by min and max, aligned by step
13273 _values: function( index ) {
13274 var val,
13275 vals,
13276 i;
13277
13278 if ( arguments.length ) {
13279 val = this.options.values[ index ];
13280 val = this._trimAlignValue( val );
13281
13282 return val;
13283 } else if ( this.options.values && this.options.values.length ) {
13284 // .slice() creates a copy of the array
13285 // this copy gets trimmed by min and max and then returned
13286 vals = this.options.values.slice();
13287 for ( i = 0; i < vals.length; i += 1) {
13288 vals[ i ] = this._trimAlignValue( vals[ i ] );
13289 }
13290
13291 return vals;
13292 } else {
13293 return [];
13294 }
13295 },
13296
13297 // returns the step-aligned value that val is closest to, between (inclusive) min and max
13298 _trimAlignValue: function( val ) {
13299 if ( val <= this._valueMin() ) {
13300 return this._valueMin();
13301 }
13302 if ( val >= this._valueMax() ) {
13303 return this._valueMax();
13304 }
13305 var step = ( this.options.step > 0 ) ? this.options.step : 1,
13306 valModStep = (val - this._valueMin()) % step,
13307 alignValue = val - valModStep;
13308
13309 if ( Math.abs(valModStep) * 2 >= step ) {
13310 alignValue += ( valModStep > 0 ) ? step : ( -step );
13311 }
13312
13313 // Since JavaScript has problems with large floats, round
13314 // the final value to 5 digits after the decimal point (see #4124)
13315 return parseFloat( alignValue.toFixed(5) );
13316 },
13317
13318 _calculateNewMax: function() {
13319 var max = this.options.max,
13320 min = this._valueMin(),
13321 step = this.options.step,
13322 aboveMin = Math.floor( ( +( max - min ).toFixed( this._precision() ) ) / step ) * step;
13323 max = aboveMin + min;
13324 this.max = parseFloat( max.toFixed( this._precision() ) );
13325 },
13326
13327 _precision: function() {
13328 var precision = this._precisionOf( this.options.step );
13329 if ( this.options.min !== null ) {
13330 precision = Math.max( precision, this._precisionOf( this.options.min ) );
13331 }
13332 return precision;
13333 },
13334
13335 _precisionOf: function( num ) {
13336 var str = num.toString(),
13337 decimal = str.indexOf( "." );
13338 return decimal === -1 ? 0 : str.length - decimal - 1;
13339 },
13340
13341 _valueMin: function() {
13342 return this.options.min;
13343 },
13344
13345 _valueMax: function() {
13346 return this.max;
13347 },
13348
13349 _refreshValue: function() {
13350 var lastValPercent, valPercent, value, valueMin, valueMax,
13351 oRange = this.options.range,
13352 o = this.options,
13353 that = this,
13354 animate = ( !this._animateOff ) ? o.animate : false,
13355 _set = {};
13356
13357 if ( this.options.values && this.options.values.length ) {
13358 this.handles.each(function( i ) {
13359 valPercent = ( that.values(i) - that._valueMin() ) / ( that._valueMax() - that._valueMin() ) * 100;
13360 _set[ that.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
13361 $( this ).stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
13362 if ( that.options.range === true ) {
13363 if ( that.orientation === "horizontal" ) {
13364 if ( i === 0 ) {
13365 that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { left: valPercent + "%" }, o.animate );
13366 }
13367 if ( i === 1 ) {
13368 that.range[ animate ? "animate" : "css" ]( { width: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
13369 }
13370 } else {
13371 if ( i === 0 ) {
13372 that.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { bottom: ( valPercent ) + "%" }, o.animate );
13373 }
13374 if ( i === 1 ) {
13375 that.range[ animate ? "animate" : "css" ]( { height: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
13376 }
13377 }
13378 }
13379 lastValPercent = valPercent;
13380 });
13381 } else {
13382 value = this.value();
13383 valueMin = this._valueMin();
13384 valueMax = this._valueMax();
13385 valPercent = ( valueMax !== valueMin ) ?
13386 ( value - valueMin ) / ( valueMax - valueMin ) * 100 :
13387 0;
13388 _set[ this.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
13389 this.handle.stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
13390
13391 if ( oRange === "min" && this.orientation === "horizontal" ) {
13392 this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { width: valPercent + "%" }, o.animate );
13393 }
13394 if ( oRange === "max" && this.orientation === "horizontal" ) {
13395 this.range[ animate ? "animate" : "css" ]( { width: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
13396 }
13397 if ( oRange === "min" && this.orientation === "vertical" ) {
13398 this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { height: valPercent + "%" }, o.animate );
13399 }
13400 if ( oRange === "max" && this.orientation === "vertical" ) {
13401 this.range[ animate ? "animate" : "css" ]( { height: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
13402 }
13403 }
13404 },
13405
13406 _handleEvents: {
13407 keydown: function( event ) {
13408 var allowed, curVal, newVal, step,
13409 index = $( event.target ).data( "ui-slider-handle-index" );
13410
13411 switch ( event.keyCode ) {
13412 case $.ui.keyCode.HOME:
13413 case $.ui.keyCode.END:
13414 case $.ui.keyCode.PAGE_UP:
13415 case $.ui.keyCode.PAGE_DOWN:
13416 case $.ui.keyCode.UP:
13417 case $.ui.keyCode.RIGHT:
13418 case $.ui.keyCode.DOWN:
13419 case $.ui.keyCode.LEFT:
13420 event.preventDefault();
13421 if ( !this._keySliding ) {
13422 this._keySliding = true;
13423 $( event.target ).addClass( "ui-state-active" );
13424 allowed = this._start( event, index );
13425 if ( allowed === false ) {
13426 return;
13427 }
13428 }
13429 break;
13430 }
13431
13432 step = this.options.step;
13433 if ( this.options.values && this.options.values.length ) {
13434 curVal = newVal = this.values( index );
13435 } else {
13436 curVal = newVal = this.value();
13437 }
13438
13439 switch ( event.keyCode ) {
13440 case $.ui.keyCode.HOME:
13441 newVal = this._valueMin();
13442 break;
13443 case $.ui.keyCode.END:
13444 newVal = this._valueMax();
13445 break;
13446 case $.ui.keyCode.PAGE_UP:
13447 newVal = this._trimAlignValue(
13448 curVal + ( ( this._valueMax() - this._valueMin() ) / this.numPages )
13449 );
13450 break;
13451 case $.ui.keyCode.PAGE_DOWN:
13452 newVal = this._trimAlignValue(
13453 curVal - ( (this._valueMax() - this._valueMin()) / this.numPages ) );
13454 break;
13455 case $.ui.keyCode.UP:
13456 case $.ui.keyCode.RIGHT:
13457 if ( curVal === this._valueMax() ) {
13458 return;
13459 }
13460 newVal = this._trimAlignValue( curVal + step );
13461 break;
13462 case $.ui.keyCode.DOWN:
13463 case $.ui.keyCode.LEFT:
13464 if ( curVal === this._valueMin() ) {
13465 return;
13466 }
13467 newVal = this._trimAlignValue( curVal - step );
13468 break;
13469 }
13470
13471 this._slide( event, index, newVal );
13472 },
13473 keyup: function( event ) {
13474 var index = $( event.target ).data( "ui-slider-handle-index" );
13475
13476 if ( this._keySliding ) {
13477 this._keySliding = false;
13478 this._stop( event, index );
13479 this._change( event, index );
13480 $( event.target ).removeClass( "ui-state-active" );
13481 }
13482 }
13483 }
13484 });
13485
13486
13487 /*!
13488 * jQuery UI Sortable 1.11.4
13489 * http://jqueryui.com
13490 *
13491 * Copyright jQuery Foundation and other contributors
13492 * Released under the MIT license.
13493 * http://jquery.org/license
13494 *
13495 * http://api.jqueryui.com/sortable/
13496 */
13497
13498
13499 var sortable = $.widget("ui.sortable", $.ui.mouse, {
13500 version: "1.11.4",
13501 widgetEventPrefix: "sort",
13502 ready: false,
13503 options: {
13504 appendTo: "parent",
13505 axis: false,
13506 connectWith: false,
13507 containment: false,
13508 cursor: "auto",
13509 cursorAt: false,
13510 dropOnEmpty: true,
13511 forcePlaceholderSize: false,
13512 forceHelperSize: false,
13513 grid: false,
13514 handle: false,
13515 helper: "original",
13516 items: "> *",
13517 opacity: false,
13518 placeholder: false,
13519 revert: false,
13520 scroll: true,
13521 scrollSensitivity: 20,
13522 scrollSpeed: 20,
13523 scope: "default",
13524 tolerance: "intersect",
13525 zIndex: 1000,
13526
13527 // callbacks
13528 activate: null,
13529 beforeStop: null,
13530 change: null,
13531 deactivate: null,
13532 out: null,
13533 over: null,
13534 receive: null,
13535 remove: null,
13536 sort: null,
13537 start: null,
13538 stop: null,
13539 update: null
13540 },
13541
13542 _isOverAxis: function( x, reference, size ) {
13543 return ( x >= reference ) && ( x < ( reference + size ) );
13544 },
13545
13546 _isFloating: function( item ) {
13547 return (/left|right/).test(item.css("float")) || (/inline|table-cell/).test(item.css("display"));
13548 },
13549
13550 _create: function() {
13551 this.containerCache = {};
13552 this.element.addClass("ui-sortable");
13553
13554 //Get the items
13555 this.refresh();
13556
13557 //Let's determine the parent's offset
13558 this.offset = this.element.offset();
13559
13560 //Initialize mouse events for interaction
13561 this._mouseInit();
13562
13563 this._setHandleClassName();
13564
13565 //We're ready to go
13566 this.ready = true;
13567
13568 },
13569
13570 _setOption: function( key, value ) {
13571 this._super( key, value );
13572
13573 if ( key === "handle" ) {
13574 this._setHandleClassName();
13575 }
13576 },
13577
13578 _setHandleClassName: function() {
13579 this.element.find( ".ui-sortable-handle" ).removeClass( "ui-sortable-handle" );
13580 $.each( this.items, function() {
13581 ( this.instance.options.handle ?
13582 this.item.find( this.instance.options.handle ) : this.item )
13583 .addClass( "ui-sortable-handle" );
13584 });
13585 },
13586
13587 _destroy: function() {
13588 this.element
13589 .removeClass( "ui-sortable ui-sortable-disabled" )
13590 .find( ".ui-sortable-handle" )
13591 .removeClass( "ui-sortable-handle" );
13592 this._mouseDestroy();
13593
13594 for ( var i = this.items.length - 1; i >= 0; i-- ) {
13595 this.items[i].item.removeData(this.widgetName + "-item");
13596 }
13597
13598 return this;
13599 },
13600
13601 _mouseCapture: function(event, overrideHandle) {
13602 var currentItem = null,
13603 validHandle = false,
13604 that = this;
13605
13606 if (this.reverting) {
13607 return false;
13608 }
13609
13610 if(this.options.disabled || this.options.type === "static") {
13611 return false;
13612 }
13613
13614 //We have to refresh the items data once first
13615 this._refreshItems(event);
13616
13617 //Find out if the clicked node (or one of its parents) is a actual item in this.items
13618 $(event.target).parents().each(function() {
13619 if($.data(this, that.widgetName + "-item") === that) {
13620 currentItem = $(this);
13621 return false;
13622 }
13623 });
13624 if($.data(event.target, that.widgetName + "-item") === that) {
13625 currentItem = $(event.target);
13626 }
13627
13628 if(!currentItem) {
13629 return false;
13630 }
13631 if(this.options.handle && !overrideHandle) {
13632 $(this.options.handle, currentItem).find("*").addBack().each(function() {
13633 if(this === event.target) {
13634 validHandle = true;
13635 }
13636 });
13637 if(!validHandle) {
13638 return false;
13639 }
13640 }
13641
13642 this.currentItem = currentItem;
13643 this._removeCurrentsFromItems();
13644 return true;
13645
13646 },
13647
13648 _mouseStart: function(event, overrideHandle, noActivation) {
13649
13650 var i, body,
13651 o = this.options;
13652
13653 this.currentContainer = this;
13654
13655 //We only need to call refreshPositions, because the refreshItems call has been moved to mouseCapture
13656 this.refreshPositions();
13657
13658 //Create and append the visible helper
13659 this.helper = this._createHelper(event);
13660
13661 //Cache the helper size
13662 this._cacheHelperProportions();
13663
13664 /*
13665 * - Position generation -
13666 * This block generates everything position related - it's the core of draggables.
13667 */
13668
13669 //Cache the margins of the original element
13670 this._cacheMargins();
13671
13672 //Get the next scrolling parent
13673 this.scrollParent = this.helper.scrollParent();
13674
13675 //The element's absolute position on the page minus margins
13676 this.offset = this.currentItem.offset();
13677 this.offset = {
13678 top: this.offset.top - this.margins.top,
13679 left: this.offset.left - this.margins.left
13680 };
13681
13682 $.extend(this.offset, {
13683 click: { //Where the click happened, relative to the element
13684 left: event.pageX - this.offset.left,
13685 top: event.pageY - this.offset.top
13686 },
13687 parent: this._getParentOffset(),
13688 relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
13689 });
13690
13691 // Only after we got the offset, we can change the helper's position to absolute
13692 // TODO: Still need to figure out a way to make relative sorting possible
13693 this.helper.css("position", "absolute");
13694 this.cssPosition = this.helper.css("position");
13695
13696 //Generate the original position
13697 this.originalPosition = this._generatePosition(event);
13698 this.originalPageX = event.pageX;
13699 this.originalPageY = event.pageY;
13700
13701 //Adjust the mouse offset relative to the helper if "cursorAt" is supplied
13702 (o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
13703
13704 //Cache the former DOM position
13705 this.domPosition = { prev: this.currentItem.prev()[0], parent: this.currentItem.parent()[0] };
13706
13707 //If the helper is not the original, hide the original so it's not playing any role during the drag, won't cause anything bad this way
13708 if(this.helper[0] !== this.currentItem[0]) {
13709 this.currentItem.hide();
13710 }
13711
13712 //Create the placeholder
13713 this._createPlaceholder();
13714
13715 //Set a containment if given in the options
13716 if(o.containment) {
13717 this._setContainment();
13718 }
13719
13720 if( o.cursor && o.cursor !== "auto" ) { // cursor option
13721 body = this.document.find( "body" );
13722
13723 // support: IE
13724 this.storedCursor = body.css( "cursor" );
13725 body.css( "cursor", o.cursor );
13726
13727 this.storedStylesheet = $( "<style>*{ cursor: "+o.cursor+" !important; }</style>" ).appendTo( body );
13728 }
13729
13730 if(o.opacity) { // opacity option
13731 if (this.helper.css("opacity")) {
13732 this._storedOpacity = this.helper.css("opacity");
13733 }
13734 this.helper.css("opacity", o.opacity);
13735 }
13736
13737 if(o.zIndex) { // zIndex option
13738 if (this.helper.css("zIndex")) {
13739 this._storedZIndex = this.helper.css("zIndex");
13740 }
13741 this.helper.css("zIndex", o.zIndex);
13742 }
13743
13744 //Prepare scrolling
13745 if(this.scrollParent[0] !== this.document[0] && this.scrollParent[0].tagName !== "HTML") {
13746 this.overflowOffset = this.scrollParent.offset();
13747 }
13748
13749 //Call callbacks
13750 this._trigger("start", event, this._uiHash());
13751
13752 //Recache the helper size
13753 if(!this._preserveHelperProportions) {
13754 this._cacheHelperProportions();
13755 }
13756
13757
13758 //Post "activate" events to possible containers
13759 if( !noActivation ) {
13760 for ( i = this.containers.length - 1; i >= 0; i-- ) {
13761 this.containers[ i ]._trigger( "activate", event, this._uiHash( this ) );
13762 }
13763 }
13764
13765 //Prepare possible droppables
13766 if($.ui.ddmanager) {
13767 $.ui.ddmanager.current = this;
13768 }
13769
13770 if ($.ui.ddmanager && !o.dropBehaviour) {
13771 $.ui.ddmanager.prepareOffsets(this, event);
13772 }
13773
13774 this.dragging = true;
13775
13776 this.helper.addClass("ui-sortable-helper");
13777 this._mouseDrag(event); //Execute the drag once - this causes the helper not to be visible before getting its correct position
13778 return true;
13779
13780 },
13781
13782 _mouseDrag: function(event) {
13783 var i, item, itemElement, intersection,
13784 o = this.options,
13785 scrolled = false;
13786
13787 //Compute the helpers position
13788 this.position = this._generatePosition(event);
13789 this.positionAbs = this._convertPositionTo("absolute");
13790
13791 if (!this.lastPositionAbs) {
13792 this.lastPositionAbs = this.positionAbs;
13793 }
13794
13795 //Do scrolling
13796 if(this.options.scroll) {
13797 if(this.scrollParent[0] !== this.document[0] && this.scrollParent[0].tagName !== "HTML") {
13798
13799 if((this.overflowOffset.top + this.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity) {
13800 this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop + o.scrollSpeed;
13801 } else if(event.pageY - this.overflowOffset.top < o.scrollSensitivity) {
13802 this.scrollParent[0].scrollTop = scrolled = this.scrollParent[0].scrollTop - o.scrollSpeed;
13803 }
13804
13805 if((this.overflowOffset.left + this.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity) {
13806 this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft + o.scrollSpeed;
13807 } else if(event.pageX - this.overflowOffset.left < o.scrollSensitivity) {
13808 this.scrollParent[0].scrollLeft = scrolled = this.scrollParent[0].scrollLeft - o.scrollSpeed;
13809 }
13810
13811 } else {
13812
13813 if(event.pageY - this.document.scrollTop() < o.scrollSensitivity) {
13814 scrolled = this.document.scrollTop(this.document.scrollTop() - o.scrollSpeed);
13815 } else if(this.window.height() - (event.pageY - this.document.scrollTop()) < o.scrollSensitivity) {
13816 scrolled = this.document.scrollTop(this.document.scrollTop() + o.scrollSpeed);
13817 }
13818
13819 if(event.pageX - this.document.scrollLeft() < o.scrollSensitivity) {
13820 scrolled = this.document.scrollLeft(this.document.scrollLeft() - o.scrollSpeed);
13821 } else if(this.window.width() - (event.pageX - this.document.scrollLeft()) < o.scrollSensitivity) {
13822 scrolled = this.document.scrollLeft(this.document.scrollLeft() + o.scrollSpeed);
13823 }
13824
13825 }
13826
13827 if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour) {
13828 $.ui.ddmanager.prepareOffsets(this, event);
13829 }
13830 }
13831
13832 //Regenerate the absolute position used for position checks
13833 this.positionAbs = this._convertPositionTo("absolute");
13834
13835 //Set the helper position
13836 if(!this.options.axis || this.options.axis !== "y") {
13837 this.helper[0].style.left = this.position.left+"px";
13838 }
13839 if(!this.options.axis || this.options.axis !== "x") {
13840 this.helper[0].style.top = this.position.top+"px";
13841 }
13842
13843 //Rearrange
13844 for (i = this.items.length - 1; i >= 0; i--) {
13845
13846 //Cache variables and intersection, continue if no intersection
13847 item = this.items[i];
13848 itemElement = item.item[0];
13849 intersection = this._intersectsWithPointer(item);
13850 if (!intersection) {
13851 continue;
13852 }
13853
13854 // Only put the placeholder inside the current Container, skip all
13855 // items from other containers. This works because when moving
13856 // an item from one container to another the
13857 // currentContainer is switched before the placeholder is moved.
13858 //
13859 // Without this, moving items in "sub-sortables" can cause
13860 // the placeholder to jitter between the outer and inner container.
13861 if (item.instance !== this.currentContainer) {
13862 continue;
13863 }
13864
13865 // cannot intersect with itself
13866 // no useless actions that have been done before
13867 // no action if the item moved is the parent of the item checked
13868 if (itemElement !== this.currentItem[0] &&
13869 this.placeholder[intersection === 1 ? "next" : "prev"]()[0] !== itemElement &&
13870 !$.contains(this.placeholder[0], itemElement) &&
13871 (this.options.type === "semi-dynamic" ? !$.contains(this.element[0], itemElement) : true)
13872 ) {
13873
13874 this.direction = intersection === 1 ? "down" : "up";
13875
13876 if (this.options.tolerance === "pointer" || this._intersectsWithSides(item)) {
13877 this._rearrange(event, item);
13878 } else {
13879 break;
13880 }
13881
13882 this._trigger("change", event, this._uiHash());
13883 break;
13884 }
13885 }
13886
13887 //Post events to containers
13888 this._contactContainers(event);
13889
13890 //Interconnect with droppables
13891 if($.ui.ddmanager) {
13892 $.ui.ddmanager.drag(this, event);
13893 }
13894
13895 //Call callbacks
13896 this._trigger("sort", event, this._uiHash());
13897
13898 this.lastPositionAbs = this.positionAbs;
13899 return false;
13900
13901 },
13902
13903 _mouseStop: function(event, noPropagation) {
13904
13905 if(!event) {
13906 return;
13907 }
13908
13909 //If we are using droppables, inform the manager about the drop
13910 if ($.ui.ddmanager && !this.options.dropBehaviour) {
13911 $.ui.ddmanager.drop(this, event);
13912 }
13913
13914 if(this.options.revert) {
13915 var that = this,
13916 cur = this.placeholder.offset(),
13917 axis = this.options.axis,
13918 animation = {};
13919
13920 if ( !axis || axis === "x" ) {
13921 animation.left = cur.left - this.offset.parent.left - this.margins.left + (this.offsetParent[0] === this.document[0].body ? 0 : this.offsetParent[0].scrollLeft);
13922 }
13923 if ( !axis || axis === "y" ) {
13924 animation.top = cur.top - this.offset.parent.top - this.margins.top + (this.offsetParent[0] === this.document[0].body ? 0 : this.offsetParent[0].scrollTop);
13925 }
13926 this.reverting = true;
13927 $(this.helper).animate( animation, parseInt(this.options.revert, 10) || 500, function() {
13928 that._clear(event);
13929 });
13930 } else {
13931 this._clear(event, noPropagation);
13932 }
13933
13934 return false;
13935
13936 },
13937
13938 cancel: function() {
13939
13940 if(this.dragging) {
13941
13942 this._mouseUp({ target: null });
13943
13944 if(this.options.helper === "original") {
13945 this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
13946 } else {
13947 this.currentItem.show();
13948 }
13949
13950 //Post deactivating events to containers
13951 for (var i = this.containers.length - 1; i >= 0; i--){
13952 this.containers[i]._trigger("deactivate", null, this._uiHash(this));
13953 if(this.containers[i].containerCache.over) {
13954 this.containers[i]._trigger("out", null, this._uiHash(this));
13955 this.containers[i].containerCache.over = 0;
13956 }
13957 }
13958
13959 }
13960
13961 if (this.placeholder) {
13962 //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
13963 if(this.placeholder[0].parentNode) {
13964 this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
13965 }
13966 if(this.options.helper !== "original" && this.helper && this.helper[0].parentNode) {
13967 this.helper.remove();
13968 }
13969
13970 $.extend(this, {
13971 helper: null,
13972 dragging: false,
13973 reverting: false,
13974 _noFinalSort: null
13975 });
13976
13977 if(this.domPosition.prev) {
13978 $(this.domPosition.prev).after(this.currentItem);
13979 } else {
13980 $(this.domPosition.parent).prepend(this.currentItem);
13981 }
13982 }
13983
13984 return this;
13985
13986 },
13987
13988 serialize: function(o) {
13989
13990 var items = this._getItemsAsjQuery(o && o.connected),
13991 str = [];
13992 o = o || {};
13993
13994 $(items).each(function() {
13995 var res = ($(o.item || this).attr(o.attribute || "id") || "").match(o.expression || (/(.+)[\-=_](.+)/));
13996 if (res) {
13997 str.push((o.key || res[1]+"[]")+"="+(o.key && o.expression ? res[1] : res[2]));
13998 }
13999 });
14000
14001 if(!str.length && o.key) {
14002 str.push(o.key + "=");
14003 }
14004
14005 return str.join("&");
14006
14007 },
14008
14009 toArray: function(o) {
14010
14011 var items = this._getItemsAsjQuery(o && o.connected),
14012 ret = [];
14013
14014 o = o || {};
14015
14016 items.each(function() { ret.push($(o.item || this).attr(o.attribute || "id") || ""); });
14017 return ret;
14018
14019 },
14020
14021 /* Be careful with the following core functions */
14022 _intersectsWith: function(item) {
14023
14024 var x1 = this.positionAbs.left,
14025 x2 = x1 + this.helperProportions.width,
14026 y1 = this.positionAbs.top,
14027 y2 = y1 + this.helperProportions.height,
14028 l = item.left,
14029 r = l + item.width,
14030 t = item.top,
14031 b = t + item.height,
14032 dyClick = this.offset.click.top,
14033 dxClick = this.offset.click.left,
14034 isOverElementHeight = ( this.options.axis === "x" ) || ( ( y1 + dyClick ) > t && ( y1 + dyClick ) < b ),
14035 isOverElementWidth = ( this.options.axis === "y" ) || ( ( x1 + dxClick ) > l && ( x1 + dxClick ) < r ),
14036 isOverElement = isOverElementHeight && isOverElementWidth;
14037
14038 if ( this.options.tolerance === "pointer" ||
14039 this.options.forcePointerForContainers ||
14040 (this.options.tolerance !== "pointer" && this.helperProportions[this.floating ? "width" : "height"] > item[this.floating ? "width" : "height"])
14041 ) {
14042 return isOverElement;
14043 } else {
14044
14045 return (l < x1 + (this.helperProportions.width / 2) && // Right Half
14046 x2 - (this.helperProportions.width / 2) < r && // Left Half
14047 t < y1 + (this.helperProportions.height / 2) && // Bottom Half
14048 y2 - (this.helperProportions.height / 2) < b ); // Top Half
14049
14050 }
14051 },
14052
14053 _intersectsWithPointer: function(item) {
14054
14055 var isOverElementHeight = (this.options.axis === "x") || this._isOverAxis(this.positionAbs.top + this.offset.click.top, item.top, item.height),
14056 isOverElementWidth = (this.options.axis === "y") || this._isOverAxis(this.positionAbs.left + this.offset.click.left, item.left, item.width),
14057 isOverElement = isOverElementHeight && isOverElementWidth,
14058 verticalDirection = this._getDragVerticalDirection(),
14059 horizontalDirection = this._getDragHorizontalDirection();
14060
14061 if (!isOverElement) {
14062 return false;
14063 }
14064
14065 return this.floating ?
14066 ( ((horizontalDirection && horizontalDirection === "right") || verticalDirection === "down") ? 2 : 1 )
14067 : ( verticalDirection && (verticalDirection === "down" ? 2 : 1) );
14068
14069 },
14070
14071 _intersectsWithSides: function(item) {
14072
14073 var isOverBottomHalf = this._isOverAxis(this.positionAbs.top + this.offset.click.top, item.top + (item.height/2), item.height),
14074 isOverRightHalf = this._isOverAxis(this.positionAbs.left + this.offset.click.left, item.left + (item.width/2), item.width),
14075 verticalDirection = this._getDragVerticalDirection(),
14076 horizontalDirection = this._getDragHorizontalDirection();
14077
14078 if (this.floating && horizontalDirection) {
14079 return ((horizontalDirection === "right" && isOverRightHalf) || (horizontalDirection === "left" && !isOverRightHalf));
14080 } else {
14081 return verticalDirection && ((verticalDirection === "down" && isOverBottomHalf) || (verticalDirection === "up" && !isOverBottomHalf));
14082 }
14083
14084 },
14085
14086 _getDragVerticalDirection: function() {
14087 var delta = this.positionAbs.top - this.lastPositionAbs.top;
14088 return delta !== 0 && (delta > 0 ? "down" : "up");
14089 },
14090
14091 _getDragHorizontalDirection: function() {
14092 var delta = this.positionAbs.left - this.lastPositionAbs.left;
14093 return delta !== 0 && (delta > 0 ? "right" : "left");
14094 },
14095
14096 refresh: function(event) {
14097 this._refreshItems(event);
14098 this._setHandleClassName();
14099 this.refreshPositions();
14100 return this;
14101 },
14102
14103 _connectWith: function() {
14104 var options = this.options;
14105 return options.connectWith.constructor === String ? [options.connectWith] : options.connectWith;
14106 },
14107
14108 _getItemsAsjQuery: function(connected) {
14109
14110 var i, j, cur, inst,
14111 items = [],
14112 queries = [],
14113 connectWith = this._connectWith();
14114
14115 if(connectWith && connected) {
14116 for (i = connectWith.length - 1; i >= 0; i--){
14117 cur = $(connectWith[i], this.document[0]);
14118 for ( j = cur.length - 1; j >= 0; j--){
14119 inst = $.data(cur[j], this.widgetFullName);
14120 if(inst && inst !== this && !inst.options.disabled) {
14121 queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element) : $(inst.options.items, inst.element).not(".ui-sortable-helper").not(".ui-sortable-placeholder"), inst]);
14122 }
14123 }
14124 }
14125 }
14126
14127 queries.push([$.isFunction(this.options.items) ? this.options.items.call(this.element, null, { options: this.options, item: this.currentItem }) : $(this.options.items, this.element).not(".ui-sortable-helper").not(".ui-sortable-placeholder"), this]);
14128
14129 function addItems() {
14130 items.push( this );
14131 }
14132 for (i = queries.length - 1; i >= 0; i--){
14133 queries[i][0].each( addItems );
14134 }
14135
14136 return $(items);
14137
14138 },
14139
14140 _removeCurrentsFromItems: function() {
14141
14142 var list = this.currentItem.find(":data(" + this.widgetName + "-item)");
14143
14144 this.items = $.grep(this.items, function (item) {
14145 for (var j=0; j < list.length; j++) {
14146 if(list[j] === item.item[0]) {
14147 return false;
14148 }
14149 }
14150 return true;
14151 });
14152
14153 },
14154
14155 _refreshItems: function(event) {
14156
14157 this.items = [];
14158 this.containers = [this];
14159
14160 var i, j, cur, inst, targetData, _queries, item, queriesLength,
14161 items = this.items,
14162 queries = [[$.isFunction(this.options.items) ? this.options.items.call(this.element[0], event, { item: this.currentItem }) : $(this.options.items, this.element), this]],
14163 connectWith = this._connectWith();
14164
14165 if(connectWith && this.ready) { //Shouldn't be run the first time through due to massive slow-down
14166 for (i = connectWith.length - 1; i >= 0; i--){
14167 cur = $(connectWith[i], this.document[0]);
14168 for (j = cur.length - 1; j >= 0; j--){
14169 inst = $.data(cur[j], this.widgetFullName);
14170 if(inst && inst !== this && !inst.options.disabled) {
14171 queries.push([$.isFunction(inst.options.items) ? inst.options.items.call(inst.element[0], event, { item: this.currentItem }) : $(inst.options.items, inst.element), inst]);
14172 this.containers.push(inst);
14173 }
14174 }
14175 }
14176 }
14177
14178 for (i = queries.length - 1; i >= 0; i--) {
14179 targetData = queries[i][1];
14180 _queries = queries[i][0];
14181
14182 for (j=0, queriesLength = _queries.length; j < queriesLength; j++) {
14183 item = $(_queries[j]);
14184
14185 item.data(this.widgetName + "-item", targetData); // Data for target checking (mouse manager)
14186
14187 items.push({
14188 item: item,
14189 instance: targetData,
14190 width: 0, height: 0,
14191 left: 0, top: 0
14192 });
14193 }
14194 }
14195
14196 },
14197
14198 refreshPositions: function(fast) {
14199
14200 // Determine whether items are being displayed horizontally
14201 this.floating = this.items.length ?
14202 this.options.axis === "x" || this._isFloating( this.items[ 0 ].item ) :
14203 false;
14204
14205 //This has to be redone because due to the item being moved out/into the offsetParent, the offsetParent's position will change
14206 if(this.offsetParent && this.helper) {
14207 this.offset.parent = this._getParentOffset();
14208 }
14209
14210 var i, item, t, p;
14211
14212 for (i = this.items.length - 1; i >= 0; i--){
14213 item = this.items[i];
14214
14215 //We ignore calculating positions of all connected containers when we're not over them
14216 if(item.instance !== this.currentContainer && this.currentContainer && item.item[0] !== this.currentItem[0]) {
14217 continue;
14218 }
14219
14220 t = this.options.toleranceElement ? $(this.options.toleranceElement, item.item) : item.item;
14221
14222 if (!fast) {
14223 item.width = t.outerWidth();
14224 item.height = t.outerHeight();
14225 }
14226
14227 p = t.offset();
14228 item.left = p.left;
14229 item.top = p.top;
14230 }
14231
14232 if(this.options.custom && this.options.custom.refreshContainers) {
14233 this.options.custom.refreshContainers.call(this);
14234 } else {
14235 for (i = this.containers.length - 1; i >= 0; i--){
14236 p = this.containers[i].element.offset();
14237 this.containers[i].containerCache.left = p.left;
14238 this.containers[i].containerCache.top = p.top;
14239 this.containers[i].containerCache.width = this.containers[i].element.outerWidth();
14240 this.containers[i].containerCache.height = this.containers[i].element.outerHeight();
14241 }
14242 }
14243
14244 return this;
14245 },
14246
14247 _createPlaceholder: function(that) {
14248 that = that || this;
14249 var className,
14250 o = that.options;
14251
14252 if(!o.placeholder || o.placeholder.constructor === String) {
14253 className = o.placeholder;
14254 o.placeholder = {
14255 element: function() {
14256
14257 var nodeName = that.currentItem[0].nodeName.toLowerCase(),
14258 element = $( "<" + nodeName + ">", that.document[0] )
14259 .addClass(className || that.currentItem[0].className+" ui-sortable-placeholder")
14260 .removeClass("ui-sortable-helper");
14261
14262 if ( nodeName === "tbody" ) {
14263 that._createTrPlaceholder(
14264 that.currentItem.find( "tr" ).eq( 0 ),
14265 $( "<tr>", that.document[ 0 ] ).appendTo( element )
14266 );
14267 } else if ( nodeName === "tr" ) {
14268 that._createTrPlaceholder( that.currentItem, element );
14269 } else if ( nodeName === "img" ) {
14270 element.attr( "src", that.currentItem.attr( "src" ) );
14271 }
14272
14273 if ( !className ) {
14274 element.css( "visibility", "hidden" );
14275 }
14276
14277 return element;
14278 },
14279 update: function(container, p) {
14280
14281 // 1. If a className is set as 'placeholder option, we don't force sizes - the class is responsible for that
14282 // 2. The option 'forcePlaceholderSize can be enabled to force it even if a class name is specified
14283 if(className && !o.forcePlaceholderSize) {
14284 return;
14285 }
14286
14287 //If the element doesn't have a actual height by itself (without styles coming from a stylesheet), it receives the inline height from the dragged item
14288 if(!p.height()) { p.height(that.currentItem.innerHeight() - parseInt(that.currentItem.css("paddingTop")||0, 10) - parseInt(that.currentItem.css("paddingBottom")||0, 10)); }
14289 if(!p.width()) { p.width(that.currentItem.innerWidth() - parseInt(that.currentItem.css("paddingLeft")||0, 10) - parseInt(that.currentItem.css("paddingRight")||0, 10)); }
14290 }
14291 };
14292 }
14293
14294 //Create the placeholder
14295 that.placeholder = $(o.placeholder.element.call(that.element, that.currentItem));
14296
14297 //Append it after the actual current item
14298 that.currentItem.after(that.placeholder);
14299
14300 //Update the size of the placeholder (TODO: Logic to fuzzy, see line 316/317)
14301 o.placeholder.update(that, that.placeholder);
14302
14303 },
14304
14305 _createTrPlaceholder: function( sourceTr, targetTr ) {
14306 var that = this;
14307
14308 sourceTr.children().each(function() {
14309 $( "<td> </td>", that.document[ 0 ] )
14310 .attr( "colspan", $( this ).attr( "colspan" ) || 1 )
14311 .appendTo( targetTr );
14312 });
14313 },
14314
14315 _contactContainers: function(event) {
14316 var i, j, dist, itemWithLeastDistance, posProperty, sizeProperty, cur, nearBottom, floating, axis,
14317 innermostContainer = null,
14318 innermostIndex = null;
14319
14320 // get innermost container that intersects with item
14321 for (i = this.containers.length - 1; i >= 0; i--) {
14322
14323 // never consider a container that's located within the item itself
14324 if($.contains(this.currentItem[0], this.containers[i].element[0])) {
14325 continue;
14326 }
14327
14328 if(this._intersectsWith(this.containers[i].containerCache)) {
14329
14330 // if we've already found a container and it's more "inner" than this, then continue
14331 if(innermostContainer && $.contains(this.containers[i].element[0], innermostContainer.element[0])) {
14332 continue;
14333 }
14334
14335 innermostContainer = this.containers[i];
14336 innermostIndex = i;
14337
14338 } else {
14339 // container doesn't intersect. trigger "out" event if necessary
14340 if(this.containers[i].containerCache.over) {
14341 this.containers[i]._trigger("out", event, this._uiHash(this));
14342 this.containers[i].containerCache.over = 0;
14343 }
14344 }
14345
14346 }
14347
14348 // if no intersecting containers found, return
14349 if(!innermostContainer) {
14350 return;
14351 }
14352
14353 // move the item into the container if it's not there already
14354 if(this.containers.length === 1) {
14355 if (!this.containers[innermostIndex].containerCache.over) {
14356 this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
14357 this.containers[innermostIndex].containerCache.over = 1;
14358 }
14359 } else {
14360
14361 //When entering a new container, we will find the item with the least distance and append our item near it
14362 dist = 10000;
14363 itemWithLeastDistance = null;
14364 floating = innermostContainer.floating || this._isFloating(this.currentItem);
14365 posProperty = floating ? "left" : "top";
14366 sizeProperty = floating ? "width" : "height";
14367 axis = floating ? "clientX" : "clientY";
14368
14369 for (j = this.items.length - 1; j >= 0; j--) {
14370 if(!$.contains(this.containers[innermostIndex].element[0], this.items[j].item[0])) {
14371 continue;
14372 }
14373 if(this.items[j].item[0] === this.currentItem[0]) {
14374 continue;
14375 }
14376
14377 cur = this.items[j].item.offset()[posProperty];
14378 nearBottom = false;
14379 if ( event[ axis ] - cur > this.items[ j ][ sizeProperty ] / 2 ) {
14380 nearBottom = true;
14381 }
14382
14383 if ( Math.abs( event[ axis ] - cur ) < dist ) {
14384 dist = Math.abs( event[ axis ] - cur );
14385 itemWithLeastDistance = this.items[ j ];
14386 this.direction = nearBottom ? "up": "down";
14387 }
14388 }
14389
14390 //Check if dropOnEmpty is enabled
14391 if(!itemWithLeastDistance && !this.options.dropOnEmpty) {
14392 return;
14393 }
14394
14395 if(this.currentContainer === this.containers[innermostIndex]) {
14396 if ( !this.currentContainer.containerCache.over ) {
14397 this.containers[ innermostIndex ]._trigger( "over", event, this._uiHash() );
14398 this.currentContainer.containerCache.over = 1;
14399 }
14400 return;
14401 }
14402
14403 itemWithLeastDistance ? this._rearrange(event, itemWithLeastDistance, null, true) : this._rearrange(event, null, this.containers[innermostIndex].element, true);
14404 this._trigger("change", event, this._uiHash());
14405 this.containers[innermostIndex]._trigger("change", event, this._uiHash(this));
14406 this.currentContainer = this.containers[innermostIndex];
14407
14408 //Update the placeholder
14409 this.options.placeholder.update(this.currentContainer, this.placeholder);
14410
14411 this.containers[innermostIndex]._trigger("over", event, this._uiHash(this));
14412 this.containers[innermostIndex].containerCache.over = 1;
14413 }
14414
14415
14416 },
14417
14418 _createHelper: function(event) {
14419
14420 var o = this.options,
14421 helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event, this.currentItem])) : (o.helper === "clone" ? this.currentItem.clone() : this.currentItem);
14422
14423 //Add the helper to the DOM if that didn't happen already
14424 if(!helper.parents("body").length) {
14425 $(o.appendTo !== "parent" ? o.appendTo : this.currentItem[0].parentNode)[0].appendChild(helper[0]);
14426 }
14427
14428 if(helper[0] === this.currentItem[0]) {
14429 this._storedCSS = { width: this.currentItem[0].style.width, height: this.currentItem[0].style.height, position: this.currentItem.css("position"), top: this.currentItem.css("top"), left: this.currentItem.css("left") };
14430 }
14431
14432 if(!helper[0].style.width || o.forceHelperSize) {
14433 helper.width(this.currentItem.width());
14434 }
14435 if(!helper[0].style.height || o.forceHelperSize) {
14436 helper.height(this.currentItem.height());
14437 }
14438
14439 return helper;
14440
14441 },
14442
14443 _adjustOffsetFromHelper: function(obj) {
14444 if (typeof obj === "string") {
14445 obj = obj.split(" ");
14446 }
14447 if ($.isArray(obj)) {
14448 obj = {left: +obj[0], top: +obj[1] || 0};
14449 }
14450 if ("left" in obj) {
14451 this.offset.click.left = obj.left + this.margins.left;
14452 }
14453 if ("right" in obj) {
14454 this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
14455 }
14456 if ("top" in obj) {
14457 this.offset.click.top = obj.top + this.margins.top;
14458 }
14459 if ("bottom" in obj) {
14460 this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
14461 }
14462 },
14463
14464 _getParentOffset: function() {
14465
14466
14467 //Get the offsetParent and cache its position
14468 this.offsetParent = this.helper.offsetParent();
14469 var po = this.offsetParent.offset();
14470
14471 // This is a special case where we need to modify a offset calculated on start, since the following happened:
14472 // 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
14473 // 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
14474 // the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
14475 if(this.cssPosition === "absolute" && this.scrollParent[0] !== this.document[0] && $.contains(this.scrollParent[0], this.offsetParent[0])) {
14476 po.left += this.scrollParent.scrollLeft();
14477 po.top += this.scrollParent.scrollTop();
14478 }
14479
14480 // This needs to be actually done for all browsers, since pageX/pageY includes this information
14481 // with an ugly IE fix
14482 if( this.offsetParent[0] === this.document[0].body || (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() === "html" && $.ui.ie)) {
14483 po = { top: 0, left: 0 };
14484 }
14485
14486 return {
14487 top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
14488 left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
14489 };
14490
14491 },
14492
14493 _getRelativeOffset: function() {
14494
14495 if(this.cssPosition === "relative") {
14496 var p = this.currentItem.position();
14497 return {
14498 top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
14499 left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
14500 };
14501 } else {
14502 return { top: 0, left: 0 };
14503 }
14504
14505 },
14506
14507 _cacheMargins: function() {
14508 this.margins = {
14509 left: (parseInt(this.currentItem.css("marginLeft"),10) || 0),
14510 top: (parseInt(this.currentItem.css("marginTop"),10) || 0)
14511 };
14512 },
14513
14514 _cacheHelperProportions: function() {
14515 this.helperProportions = {
14516 width: this.helper.outerWidth(),
14517 height: this.helper.outerHeight()
14518 };
14519 },
14520
14521 _setContainment: function() {
14522
14523 var ce, co, over,
14524 o = this.options;
14525 if(o.containment === "parent") {
14526 o.containment = this.helper[0].parentNode;
14527 }
14528 if(o.containment === "document" || o.containment === "window") {
14529 this.containment = [
14530 0 - this.offset.relative.left - this.offset.parent.left,
14531 0 - this.offset.relative.top - this.offset.parent.top,
14532 o.containment === "document" ? this.document.width() : this.window.width() - this.helperProportions.width - this.margins.left,
14533 (o.containment === "document" ? this.document.width() : this.window.height() || this.document[0].body.parentNode.scrollHeight) - this.helperProportions.height - this.margins.top
14534 ];
14535 }
14536
14537 if(!(/^(document|window|parent)$/).test(o.containment)) {
14538 ce = $(o.containment)[0];
14539 co = $(o.containment).offset();
14540 over = ($(ce).css("overflow") !== "hidden");
14541
14542 this.containment = [
14543 co.left + (parseInt($(ce).css("borderLeftWidth"),10) || 0) + (parseInt($(ce).css("paddingLeft"),10) || 0) - this.margins.left,
14544 co.top + (parseInt($(ce).css("borderTopWidth"),10) || 0) + (parseInt($(ce).css("paddingTop"),10) || 0) - this.margins.top,
14545 co.left+(over ? Math.max(ce.scrollWidth,ce.offsetWidth) : ce.offsetWidth) - (parseInt($(ce).css("borderLeftWidth"),10) || 0) - (parseInt($(ce).css("paddingRight"),10) || 0) - this.helperProportions.width - this.margins.left,
14546 co.top+(over ? Math.max(ce.scrollHeight,ce.offsetHeight) : ce.offsetHeight) - (parseInt($(ce).css("borderTopWidth"),10) || 0) - (parseInt($(ce).css("paddingBottom"),10) || 0) - this.helperProportions.height - this.margins.top
14547 ];
14548 }
14549
14550 },
14551
14552 _convertPositionTo: function(d, pos) {
14553
14554 if(!pos) {
14555 pos = this.position;
14556 }
14557 var mod = d === "absolute" ? 1 : -1,
14558 scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== this.document[0] && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent,
14559 scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
14560
14561 return {
14562 top: (
14563 pos.top + // The absolute mouse position
14564 this.offset.relative.top * mod + // Only for relative positioned nodes: Relative offset from element to offset parent
14565 this.offset.parent.top * mod - // The offsetParent's offset without borders (offset + border)
14566 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * mod)
14567 ),
14568 left: (
14569 pos.left + // The absolute mouse position
14570 this.offset.relative.left * mod + // Only for relative positioned nodes: Relative offset from element to offset parent
14571 this.offset.parent.left * mod - // The offsetParent's offset without borders (offset + border)
14572 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ) * mod)
14573 )
14574 };
14575
14576 },
14577
14578 _generatePosition: function(event) {
14579
14580 var top, left,
14581 o = this.options,
14582 pageX = event.pageX,
14583 pageY = event.pageY,
14584 scroll = this.cssPosition === "absolute" && !(this.scrollParent[0] !== this.document[0] && $.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
14585
14586 // This is another very weird special case that only happens for relative elements:
14587 // 1. If the css position is relative
14588 // 2. and the scroll parent is the document or similar to the offset parent
14589 // we have to refresh the relative offset during the scroll so there are no jumps
14590 if(this.cssPosition === "relative" && !(this.scrollParent[0] !== this.document[0] && this.scrollParent[0] !== this.offsetParent[0])) {
14591 this.offset.relative = this._getRelativeOffset();
14592 }
14593
14594 /*
14595 * - Position constraining -
14596 * Constrain the position to a mix of grid, containment.
14597 */
14598
14599 if(this.originalPosition) { //If we are not dragging yet, we won't check for options
14600
14601 if(this.containment) {
14602 if(event.pageX - this.offset.click.left < this.containment[0]) {
14603 pageX = this.containment[0] + this.offset.click.left;
14604 }
14605 if(event.pageY - this.offset.click.top < this.containment[1]) {
14606 pageY = this.containment[1] + this.offset.click.top;
14607 }
14608 if(event.pageX - this.offset.click.left > this.containment[2]) {
14609 pageX = this.containment[2] + this.offset.click.left;
14610 }
14611 if(event.pageY - this.offset.click.top > this.containment[3]) {
14612 pageY = this.containment[3] + this.offset.click.top;
14613 }
14614 }
14615
14616 if(o.grid) {
14617 top = this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1];
14618 pageY = this.containment ? ( (top - this.offset.click.top >= this.containment[1] && top - this.offset.click.top <= this.containment[3]) ? top : ((top - this.offset.click.top >= this.containment[1]) ? top - o.grid[1] : top + o.grid[1])) : top;
14619
14620 left = this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0];
14621 pageX = this.containment ? ( (left - this.offset.click.left >= this.containment[0] && left - this.offset.click.left <= this.containment[2]) ? left : ((left - this.offset.click.left >= this.containment[0]) ? left - o.grid[0] : left + o.grid[0])) : left;
14622 }
14623
14624 }
14625
14626 return {
14627 top: (
14628 pageY - // The absolute mouse position
14629 this.offset.click.top - // Click offset (relative to the element)
14630 this.offset.relative.top - // Only for relative positioned nodes: Relative offset from element to offset parent
14631 this.offset.parent.top + // The offsetParent's offset without borders (offset + border)
14632 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ))
14633 ),
14634 left: (
14635 pageX - // The absolute mouse position
14636 this.offset.click.left - // Click offset (relative to the element)
14637 this.offset.relative.left - // Only for relative positioned nodes: Relative offset from element to offset parent
14638 this.offset.parent.left + // The offsetParent's offset without borders (offset + border)
14639 ( ( this.cssPosition === "fixed" ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ))
14640 )
14641 };
14642
14643 },
14644
14645 _rearrange: function(event, i, a, hardRefresh) {
14646
14647 a ? a[0].appendChild(this.placeholder[0]) : i.item[0].parentNode.insertBefore(this.placeholder[0], (this.direction === "down" ? i.item[0] : i.item[0].nextSibling));
14648
14649 //Various things done here to improve the performance:
14650 // 1. we create a setTimeout, that calls refreshPositions
14651 // 2. on the instance, we have a counter variable, that get's higher after every append
14652 // 3. on the local scope, we copy the counter variable, and check in the timeout, if it's still the same
14653 // 4. this lets only the last addition to the timeout stack through
14654 this.counter = this.counter ? ++this.counter : 1;
14655 var counter = this.counter;
14656
14657 this._delay(function() {
14658 if(counter === this.counter) {
14659 this.refreshPositions(!hardRefresh); //Precompute after each DOM insertion, NOT on mousemove
14660 }
14661 });
14662
14663 },
14664
14665 _clear: function(event, noPropagation) {
14666
14667 this.reverting = false;
14668 // We delay all events that have to be triggered to after the point where the placeholder has been removed and
14669 // everything else normalized again
14670 var i,
14671 delayedTriggers = [];
14672
14673 // We first have to update the dom position of the actual currentItem
14674 // Note: don't do it if the current item is already removed (by a user), or it gets reappended (see #4088)
14675 if(!this._noFinalSort && this.currentItem.parent().length) {
14676 this.placeholder.before(this.currentItem);
14677 }
14678 this._noFinalSort = null;
14679
14680 if(this.helper[0] === this.currentItem[0]) {
14681 for(i in this._storedCSS) {
14682 if(this._storedCSS[i] === "auto" || this._storedCSS[i] === "static") {
14683 this._storedCSS[i] = "";
14684 }
14685 }
14686 this.currentItem.css(this._storedCSS).removeClass("ui-sortable-helper");
14687 } else {
14688 this.currentItem.show();
14689 }
14690
14691 if(this.fromOutside && !noPropagation) {
14692 delayedTriggers.push(function(event) { this._trigger("receive", event, this._uiHash(this.fromOutside)); });
14693 }
14694 if((this.fromOutside || this.domPosition.prev !== this.currentItem.prev().not(".ui-sortable-helper")[0] || this.domPosition.parent !== this.currentItem.parent()[0]) && !noPropagation) {
14695 delayedTriggers.push(function(event) { this._trigger("update", event, this._uiHash()); }); //Trigger update callback if the DOM position has changed
14696 }
14697
14698 // Check if the items Container has Changed and trigger appropriate
14699 // events.
14700 if (this !== this.currentContainer) {
14701 if(!noPropagation) {
14702 delayedTriggers.push(function(event) { this._trigger("remove", event, this._uiHash()); });
14703 delayedTriggers.push((function(c) { return function(event) { c._trigger("receive", event, this._uiHash(this)); }; }).call(this, this.currentContainer));
14704 delayedTriggers.push((function(c) { return function(event) { c._trigger("update", event, this._uiHash(this)); }; }).call(this, this.currentContainer));
14705 }
14706 }
14707
14708
14709 //Post events to containers
14710 function delayEvent( type, instance, container ) {
14711 return function( event ) {
14712 container._trigger( type, event, instance._uiHash( instance ) );
14713 };
14714 }
14715 for (i = this.containers.length - 1; i >= 0; i--){
14716 if (!noPropagation) {
14717 delayedTriggers.push( delayEvent( "deactivate", this, this.containers[ i ] ) );
14718 }
14719 if(this.containers[i].containerCache.over) {
14720 delayedTriggers.push( delayEvent( "out", this, this.containers[ i ] ) );
14721 this.containers[i].containerCache.over = 0;
14722 }
14723 }
14724
14725 //Do what was originally in plugins
14726 if ( this.storedCursor ) {
14727 this.document.find( "body" ).css( "cursor", this.storedCursor );
14728 this.storedStylesheet.remove();
14729 }
14730 if(this._storedOpacity) {
14731 this.helper.css("opacity", this._storedOpacity);
14732 }
14733 if(this._storedZIndex) {
14734 this.helper.css("zIndex", this._storedZIndex === "auto" ? "" : this._storedZIndex);
14735 }
14736
14737 this.dragging = false;
14738
14739 if(!noPropagation) {
14740 this._trigger("beforeStop", event, this._uiHash());
14741 }
14742
14743 //$(this.placeholder[0]).remove(); would have been the jQuery way - unfortunately, it unbinds ALL events from the original node!
14744 this.placeholder[0].parentNode.removeChild(this.placeholder[0]);
14745
14746 if ( !this.cancelHelperRemoval ) {
14747 if ( this.helper[ 0 ] !== this.currentItem[ 0 ] ) {
14748 this.helper.remove();
14749 }
14750 this.helper = null;
14751 }
14752
14753 if(!noPropagation) {
14754 for (i=0; i < delayedTriggers.length; i++) {
14755 delayedTriggers[i].call(this, event);
14756 } //Trigger all delayed events
14757 this._trigger("stop", event, this._uiHash());
14758 }
14759
14760 this.fromOutside = false;
14761 return !this.cancelHelperRemoval;
14762
14763 },
14764
14765 _trigger: function() {
14766 if ($.Widget.prototype._trigger.apply(this, arguments) === false) {
14767 this.cancel();
14768 }
14769 },
14770
14771 _uiHash: function(_inst) {
14772 var inst = _inst || this;
14773 return {
14774 helper: inst.helper,
14775 placeholder: inst.placeholder || $([]),
14776 position: inst.position,
14777 originalPosition: inst.originalPosition,
14778 offset: inst.positionAbs,
14779 item: inst.currentItem,
14780 sender: _inst ? _inst.element : null
14781 };
14782 }
14783
14784 });
14785
14786
14787 /*!
14788 * jQuery UI Spinner 1.11.4
14789 * http://jqueryui.com
14790 *
14791 * Copyright jQuery Foundation and other contributors
14792 * Released under the MIT license.
14793 * http://jquery.org/license
14794 *
14795 * http://api.jqueryui.com/spinner/
14796 */
14797
14798
14799 function spinner_modifier( fn ) {
14800 return function() {
14801 var previous = this.element.val();
14802 fn.apply( this, arguments );
14803 this._refresh();
14804 if ( previous !== this.element.val() ) {
14805 this._trigger( "change" );
14806 }
14807 };
14808 }
14809
14810 var spinner = $.widget( "ui.spinner", {
14811 version: "1.11.4",
14812 defaultElement: "<input>",
14813 widgetEventPrefix: "spin",
14814 options: {
14815 culture: null,
14816 icons: {
14817 down: "ui-icon-triangle-1-s",
14818 up: "ui-icon-triangle-1-n"
14819 },
14820 incremental: true,
14821 max: null,
14822 min: null,
14823 numberFormat: null,
14824 page: 10,
14825 step: 1,
14826
14827 change: null,
14828 spin: null,
14829 start: null,
14830 stop: null
14831 },
14832
14833 _create: function() {
14834 // handle string values that need to be parsed
14835 this._setOption( "max", this.options.max );
14836 this._setOption( "min", this.options.min );
14837 this._setOption( "step", this.options.step );
14838
14839 // Only format if there is a value, prevents the field from being marked
14840 // as invalid in Firefox, see #9573.
14841 if ( this.value() !== "" ) {
14842 // Format the value, but don't constrain.
14843 this._value( this.element.val(), true );
14844 }
14845
14846 this._draw();
14847 this._on( this._events );
14848 this._refresh();
14849
14850 // turning off autocomplete prevents the browser from remembering the
14851 // value when navigating through history, so we re-enable autocomplete
14852 // if the page is unloaded before the widget is destroyed. #7790
14853 this._on( this.window, {
14854 beforeunload: function() {
14855 this.element.removeAttr( "autocomplete" );
14856 }
14857 });
14858 },
14859
14860 _getCreateOptions: function() {
14861 var options = {},
14862 element = this.element;
14863
14864 $.each( [ "min", "max", "step" ], function( i, option ) {
14865 var value = element.attr( option );
14866 if ( value !== undefined && value.length ) {
14867 options[ option ] = value;
14868 }
14869 });
14870
14871 return options;
14872 },
14873
14874 _events: {
14875 keydown: function( event ) {
14876 if ( this._start( event ) && this._keydown( event ) ) {
14877 event.preventDefault();
14878 }
14879 },
14880 keyup: "_stop",
14881 focus: function() {
14882 this.previous = this.element.val();
14883 },
14884 blur: function( event ) {
14885 if ( this.cancelBlur ) {
14886 delete this.cancelBlur;
14887 return;
14888 }
14889
14890 this._stop();
14891 this._refresh();
14892 if ( this.previous !== this.element.val() ) {
14893 this._trigger( "change", event );
14894 }
14895 },
14896 mousewheel: function( event, delta ) {
14897 if ( !delta ) {
14898 return;
14899 }
14900 if ( !this.spinning && !this._start( event ) ) {
14901 return false;
14902 }
14903
14904 this._spin( (delta > 0 ? 1 : -1) * this.options.step, event );
14905 clearTimeout( this.mousewheelTimer );
14906 this.mousewheelTimer = this._delay(function() {
14907 if ( this.spinning ) {
14908 this._stop( event );
14909 }
14910 }, 100 );
14911 event.preventDefault();
14912 },
14913 "mousedown .ui-spinner-button": function( event ) {
14914 var previous;
14915
14916 // We never want the buttons to have focus; whenever the user is
14917 // interacting with the spinner, the focus should be on the input.
14918 // If the input is focused then this.previous is properly set from
14919 // when the input first received focus. If the input is not focused
14920 // then we need to set this.previous based on the value before spinning.
14921 previous = this.element[0] === this.document[0].activeElement ?
14922 this.previous : this.element.val();
14923 function checkFocus() {
14924 var isActive = this.element[0] === this.document[0].activeElement;
14925 if ( !isActive ) {
14926 this.element.focus();
14927 this.previous = previous;
14928 // support: IE
14929 // IE sets focus asynchronously, so we need to check if focus
14930 // moved off of the input because the user clicked on the button.
14931 this._delay(function() {
14932 this.previous = previous;
14933 });
14934 }
14935 }
14936
14937 // ensure focus is on (or stays on) the text field
14938 event.preventDefault();
14939 checkFocus.call( this );
14940
14941 // support: IE
14942 // IE doesn't prevent moving focus even with event.preventDefault()
14943 // so we set a flag to know when we should ignore the blur event
14944 // and check (again) if focus moved off of the input.
14945 this.cancelBlur = true;
14946 this._delay(function() {
14947 delete this.cancelBlur;
14948 checkFocus.call( this );
14949 });
14950
14951 if ( this._start( event ) === false ) {
14952 return;
14953 }
14954
14955 this._repeat( null, $( event.currentTarget ).hasClass( "ui-spinner-up" ) ? 1 : -1, event );
14956 },
14957 "mouseup .ui-spinner-button": "_stop",
14958 "mouseenter .ui-spinner-button": function( event ) {
14959 // button will add ui-state-active if mouse was down while mouseleave and kept down
14960 if ( !$( event.currentTarget ).hasClass( "ui-state-active" ) ) {
14961 return;
14962 }
14963
14964 if ( this._start( event ) === false ) {
14965 return false;
14966 }
14967 this._repeat( null, $( event.currentTarget ).hasClass( "ui-spinner-up" ) ? 1 : -1, event );
14968 },
14969 // TODO: do we really want to consider this a stop?
14970 // shouldn't we just stop the repeater and wait until mouseup before
14971 // we trigger the stop event?
14972 "mouseleave .ui-spinner-button": "_stop"
14973 },
14974
14975 _draw: function() {
14976 var uiSpinner = this.uiSpinner = this.element
14977 .addClass( "ui-spinner-input" )
14978 .attr( "autocomplete", "off" )
14979 .wrap( this._uiSpinnerHtml() )
14980 .parent()
14981 // add buttons
14982 .append( this._buttonHtml() );
14983
14984 this.element.attr( "role", "spinbutton" );
14985
14986 // button bindings
14987 this.buttons = uiSpinner.find( ".ui-spinner-button" )
14988 .attr( "tabIndex", -1 )
14989 .button()
14990 .removeClass( "ui-corner-all" );
14991
14992 // IE 6 doesn't understand height: 50% for the buttons
14993 // unless the wrapper has an explicit height
14994 if ( this.buttons.height() > Math.ceil( uiSpinner.height() * 0.5 ) &&
14995 uiSpinner.height() > 0 ) {
14996 uiSpinner.height( uiSpinner.height() );
14997 }
14998
14999 // disable spinner if element was already disabled
15000 if ( this.options.disabled ) {
15001 this.disable();
15002 }
15003 },
15004
15005 _keydown: function( event ) {
15006 var options = this.options,
15007 keyCode = $.ui.keyCode;
15008
15009 switch ( event.keyCode ) {
15010 case keyCode.UP:
15011 this._repeat( null, 1, event );
15012 return true;
15013 case keyCode.DOWN:
15014 this._repeat( null, -1, event );
15015 return true;
15016 case keyCode.PAGE_UP:
15017 this._repeat( null, options.page, event );
15018 return true;
15019 case keyCode.PAGE_DOWN:
15020 this._repeat( null, -options.page, event );
15021 return true;
15022 }
15023
15024 return false;
15025 },
15026
15027 _uiSpinnerHtml: function() {
15028 return "<span class='ui-spinner ui-widget ui-widget-content ui-corner-all'></span>";
15029 },
15030
15031 _buttonHtml: function() {
15032 return "" +
15033 "<a class='ui-spinner-button ui-spinner-up ui-corner-tr'>" +
15034 "<span class='ui-icon " + this.options.icons.up + "'>▲</span>" +
15035 "</a>" +
15036 "<a class='ui-spinner-button ui-spinner-down ui-corner-br'>" +
15037 "<span class='ui-icon " + this.options.icons.down + "'>▼</span>" +
15038 "</a>";
15039 },
15040
15041 _start: function( event ) {
15042 if ( !this.spinning && this._trigger( "start", event ) === false ) {
15043 return false;
15044 }
15045
15046 if ( !this.counter ) {
15047 this.counter = 1;
15048 }
15049 this.spinning = true;
15050 return true;
15051 },
15052
15053 _repeat: function( i, steps, event ) {
15054 i = i || 500;
15055
15056 clearTimeout( this.timer );
15057 this.timer = this._delay(function() {
15058 this._repeat( 40, steps, event );
15059 }, i );
15060
15061 this._spin( steps * this.options.step, event );
15062 },
15063
15064 _spin: function( step, event ) {
15065 var value = this.value() || 0;
15066
15067 if ( !this.counter ) {
15068 this.counter = 1;
15069 }
15070
15071 value = this._adjustValue( value + step * this._increment( this.counter ) );
15072
15073 if ( !this.spinning || this._trigger( "spin", event, { value: value } ) !== false) {
15074 this._value( value );
15075 this.counter++;
15076 }
15077 },
15078
15079 _increment: function( i ) {
15080 var incremental = this.options.incremental;
15081
15082 if ( incremental ) {
15083 return $.isFunction( incremental ) ?
15084 incremental( i ) :
15085 Math.floor( i * i * i / 50000 - i * i / 500 + 17 * i / 200 + 1 );
15086 }
15087
15088 return 1;
15089 },
15090
15091 _precision: function() {
15092 var precision = this._precisionOf( this.options.step );
15093 if ( this.options.min !== null ) {
15094 precision = Math.max( precision, this._precisionOf( this.options.min ) );
15095 }
15096 return precision;
15097 },
15098
15099 _precisionOf: function( num ) {
15100 var str = num.toString(),
15101 decimal = str.indexOf( "." );
15102 return decimal === -1 ? 0 : str.length - decimal - 1;
15103 },
15104
15105 _adjustValue: function( value ) {
15106 var base, aboveMin,
15107 options = this.options;
15108
15109 // make sure we're at a valid step
15110 // - find out where we are relative to the base (min or 0)
15111 base = options.min !== null ? options.min : 0;
15112 aboveMin = value - base;
15113 // - round to the nearest step
15114 aboveMin = Math.round(aboveMin / options.step) * options.step;
15115 // - rounding is based on 0, so adjust back to our base
15116 value = base + aboveMin;
15117
15118 // fix precision from bad JS floating point math
15119 value = parseFloat( value.toFixed( this._precision() ) );
15120
15121 // clamp the value
15122 if ( options.max !== null && value > options.max) {
15123 return options.max;
15124 }
15125 if ( options.min !== null && value < options.min ) {
15126 return options.min;
15127 }
15128
15129 return value;
15130 },
15131
15132 _stop: function( event ) {
15133 if ( !this.spinning ) {
15134 return;
15135 }
15136
15137 clearTimeout( this.timer );
15138 clearTimeout( this.mousewheelTimer );
15139 this.counter = 0;
15140 this.spinning = false;
15141 this._trigger( "stop", event );
15142 },
15143
15144 _setOption: function( key, value ) {
15145 if ( key === "culture" || key === "numberFormat" ) {
15146 var prevValue = this._parse( this.element.val() );
15147 this.options[ key ] = value;
15148 this.element.val( this._format( prevValue ) );
15149 return;
15150 }
15151
15152 if ( key === "max" || key === "min" || key === "step" ) {
15153 if ( typeof value === "string" ) {
15154 value = this._parse( value );
15155 }
15156 }
15157 if ( key === "icons" ) {
15158 this.buttons.first().find( ".ui-icon" )
15159 .removeClass( this.options.icons.up )
15160 .addClass( value.up );
15161 this.buttons.last().find( ".ui-icon" )
15162 .removeClass( this.options.icons.down )
15163 .addClass( value.down );
15164 }
15165
15166 this._super( key, value );
15167
15168 if ( key === "disabled" ) {
15169 this.widget().toggleClass( "ui-state-disabled", !!value );
15170 this.element.prop( "disabled", !!value );
15171 this.buttons.button( value ? "disable" : "enable" );
15172 }
15173 },
15174
15175 _setOptions: spinner_modifier(function( options ) {
15176 this._super( options );
15177 }),
15178
15179 _parse: function( val ) {
15180 if ( typeof val === "string" && val !== "" ) {
15181 val = window.Globalize && this.options.numberFormat ?
15182 Globalize.parseFloat( val, 10, this.options.culture ) : +val;
15183 }
15184 return val === "" || isNaN( val ) ? null : val;
15185 },
15186
15187 _format: function( value ) {
15188 if ( value === "" ) {
15189 return "";
15190 }
15191 return window.Globalize && this.options.numberFormat ?
15192 Globalize.format( value, this.options.numberFormat, this.options.culture ) :
15193 value;
15194 },
15195
15196 _refresh: function() {
15197 this.element.attr({
15198 "aria-valuemin": this.options.min,
15199 "aria-valuemax": this.options.max,
15200 // TODO: what should we do with values that can't be parsed?
15201 "aria-valuenow": this._parse( this.element.val() )
15202 });
15203 },
15204
15205 isValid: function() {
15206 var value = this.value();
15207
15208 // null is invalid
15209 if ( value === null ) {
15210 return false;
15211 }
15212
15213 // if value gets adjusted, it's invalid
15214 return value === this._adjustValue( value );
15215 },
15216
15217 // update the value without triggering change
15218 _value: function( value, allowAny ) {
15219 var parsed;
15220 if ( value !== "" ) {
15221 parsed = this._parse( value );
15222 if ( parsed !== null ) {
15223 if ( !allowAny ) {
15224 parsed = this._adjustValue( parsed );
15225 }
15226 value = this._format( parsed );
15227 }
15228 }
15229 this.element.val( value );
15230 this._refresh();
15231 },
15232
15233 _destroy: function() {
15234 this.element
15235 .removeClass( "ui-spinner-input" )
15236 .prop( "disabled", false )
15237 .removeAttr( "autocomplete" )
15238 .removeAttr( "role" )
15239 .removeAttr( "aria-valuemin" )
15240 .removeAttr( "aria-valuemax" )
15241 .removeAttr( "aria-valuenow" );
15242 this.uiSpinner.replaceWith( this.element );
15243 },
15244
15245 stepUp: spinner_modifier(function( steps ) {
15246 this._stepUp( steps );
15247 }),
15248 _stepUp: function( steps ) {
15249 if ( this._start() ) {
15250 this._spin( (steps || 1) * this.options.step );
15251 this._stop();
15252 }
15253 },
15254
15255 stepDown: spinner_modifier(function( steps ) {
15256 this._stepDown( steps );
15257 }),
15258 _stepDown: function( steps ) {
15259 if ( this._start() ) {
15260 this._spin( (steps || 1) * -this.options.step );
15261 this._stop();
15262 }
15263 },
15264
15265 pageUp: spinner_modifier(function( pages ) {
15266 this._stepUp( (pages || 1) * this.options.page );
15267 }),
15268
15269 pageDown: spinner_modifier(function( pages ) {
15270 this._stepDown( (pages || 1) * this.options.page );
15271 }),
15272
15273 value: function( newVal ) {
15274 if ( !arguments.length ) {
15275 return this._parse( this.element.val() );
15276 }
15277 spinner_modifier( this._value ).call( this, newVal );
15278 },
15279
15280 widget: function() {
15281 return this.uiSpinner;
15282 }
15283 });
15284
15285
15286 /*!
15287 * jQuery UI Tabs 1.11.4
15288 * http://jqueryui.com
15289 *
15290 * Copyright jQuery Foundation and other contributors
15291 * Released under the MIT license.
15292 * http://jquery.org/license
15293 *
15294 * http://api.jqueryui.com/tabs/
15295 */
15296
15297
15298 var tabs = $.widget( "ui.tabs", {
15299 version: "1.11.4",
15300 delay: 300,
15301 options: {
15302 active: null,
15303 collapsible: false,
15304 event: "click",
15305 heightStyle: "content",
15306 hide: null,
15307 show: null,
15308
15309 // callbacks
15310 activate: null,
15311 beforeActivate: null,
15312 beforeLoad: null,
15313 load: null
15314 },
15315
15316 _isLocal: (function() {
15317 var rhash = /#.*$/;
15318
15319 return function( anchor ) {
15320 var anchorUrl, locationUrl;
15321
15322 // support: IE7
15323 // IE7 doesn't normalize the href property when set via script (#9317)
15324 anchor = anchor.cloneNode( false );
15325
15326 anchorUrl = anchor.href.replace( rhash, "" );
15327 locationUrl = location.href.replace( rhash, "" );
15328
15329 // decoding may throw an error if the URL isn't UTF-8 (#9518)
15330 try {
15331 anchorUrl = decodeURIComponent( anchorUrl );
15332 } catch ( error ) {}
15333 try {
15334 locationUrl = decodeURIComponent( locationUrl );
15335 } catch ( error ) {}
15336
15337 return anchor.hash.length > 1 && anchorUrl === locationUrl;
15338 };
15339 })(),
15340
15341 _create: function() {
15342 var that = this,
15343 options = this.options;
15344
15345 this.running = false;
15346
15347 this.element
15348 .addClass( "ui-tabs ui-widget ui-widget-content ui-corner-all" )
15349 .toggleClass( "ui-tabs-collapsible", options.collapsible );
15350
15351 this._processTabs();
15352 options.active = this._initialActive();
15353
15354 // Take disabling tabs via class attribute from HTML
15355 // into account and update option properly.
15356 if ( $.isArray( options.disabled ) ) {
15357 options.disabled = $.unique( options.disabled.concat(
15358 $.map( this.tabs.filter( ".ui-state-disabled" ), function( li ) {
15359 return that.tabs.index( li );
15360 })
15361 ) ).sort();
15362 }
15363
15364 // check for length avoids error when initializing empty list
15365 if ( this.options.active !== false && this.anchors.length ) {
15366 this.active = this._findActive( options.active );
15367 } else {
15368 this.active = $();
15369 }
15370
15371 this._refresh();
15372
15373 if ( this.active.length ) {
15374 this.load( options.active );
15375 }
15376 },
15377
15378 _initialActive: function() {
15379 var active = this.options.active,
15380 collapsible = this.options.collapsible,
15381 locationHash = location.hash.substring( 1 );
15382
15383 if ( active === null ) {
15384 // check the fragment identifier in the URL
15385 if ( locationHash ) {
15386 this.tabs.each(function( i, tab ) {
15387 if ( $( tab ).attr( "aria-controls" ) === locationHash ) {
15388 active = i;
15389 return false;
15390 }
15391 });
15392 }
15393
15394 // check for a tab marked active via a class
15395 if ( active === null ) {
15396 active = this.tabs.index( this.tabs.filter( ".ui-tabs-active" ) );
15397 }
15398
15399 // no active tab, set to false
15400 if ( active === null || active === -1 ) {
15401 active = this.tabs.length ? 0 : false;
15402 }
15403 }
15404
15405 // handle numbers: negative, out of range
15406 if ( active !== false ) {
15407 active = this.tabs.index( this.tabs.eq( active ) );
15408 if ( active === -1 ) {
15409 active = collapsible ? false : 0;
15410 }
15411 }
15412
15413 // don't allow collapsible: false and active: false
15414 if ( !collapsible && active === false && this.anchors.length ) {
15415 active = 0;
15416 }
15417
15418 return active;
15419 },
15420
15421 _getCreateEventData: function() {
15422 return {
15423 tab: this.active,
15424 panel: !this.active.length ? $() : this._getPanelForTab( this.active )
15425 };
15426 },
15427
15428 _tabKeydown: function( event ) {
15429 var focusedTab = $( this.document[0].activeElement ).closest( "li" ),
15430 selectedIndex = this.tabs.index( focusedTab ),
15431 goingForward = true;
15432
15433 if ( this._handlePageNav( event ) ) {
15434 return;
15435 }
15436
15437 switch ( event.keyCode ) {
15438 case $.ui.keyCode.RIGHT:
15439 case $.ui.keyCode.DOWN:
15440 selectedIndex++;
15441 break;
15442 case $.ui.keyCode.UP:
15443 case $.ui.keyCode.LEFT:
15444 goingForward = false;
15445 selectedIndex--;
15446 break;
15447 case $.ui.keyCode.END:
15448 selectedIndex = this.anchors.length - 1;
15449 break;
15450 case $.ui.keyCode.HOME:
15451 selectedIndex = 0;
15452 break;
15453 case $.ui.keyCode.SPACE:
15454 // Activate only, no collapsing
15455 event.preventDefault();
15456 clearTimeout( this.activating );
15457 this._activate( selectedIndex );
15458 return;
15459 case $.ui.keyCode.ENTER:
15460 // Toggle (cancel delayed activation, allow collapsing)
15461 event.preventDefault();
15462 clearTimeout( this.activating );
15463 // Determine if we should collapse or activate
15464 this._activate( selectedIndex === this.options.active ? false : selectedIndex );
15465 return;
15466 default:
15467 return;
15468 }
15469
15470 // Focus the appropriate tab, based on which key was pressed
15471 event.preventDefault();
15472 clearTimeout( this.activating );
15473 selectedIndex = this._focusNextTab( selectedIndex, goingForward );
15474
15475 // Navigating with control/command key will prevent automatic activation
15476 if ( !event.ctrlKey && !event.metaKey ) {
15477
15478 // Update aria-selected immediately so that AT think the tab is already selected.
15479 // Otherwise AT may confuse the user by stating that they need to activate the tab,
15480 // but the tab will already be activated by the time the announcement finishes.
15481 focusedTab.attr( "aria-selected", "false" );
15482 this.tabs.eq( selectedIndex ).attr( "aria-selected", "true" );
15483
15484 this.activating = this._delay(function() {
15485 this.option( "active", selectedIndex );
15486 }, this.delay );
15487 }
15488 },
15489
15490 _panelKeydown: function( event ) {
15491 if ( this._handlePageNav( event ) ) {
15492 return;
15493 }
15494
15495 // Ctrl+up moves focus to the current tab
15496 if ( event.ctrlKey && event.keyCode === $.ui.keyCode.UP ) {
15497 event.preventDefault();
15498 this.active.focus();
15499 }
15500 },
15501
15502 // Alt+page up/down moves focus to the previous/next tab (and activates)
15503 _handlePageNav: function( event ) {
15504 if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_UP ) {
15505 this._activate( this._focusNextTab( this.options.active - 1, false ) );
15506 return true;
15507 }
15508 if ( event.altKey && event.keyCode === $.ui.keyCode.PAGE_DOWN ) {
15509 this._activate( this._focusNextTab( this.options.active + 1, true ) );
15510 return true;
15511 }
15512 },
15513
15514 _findNextTab: function( index, goingForward ) {
15515 var lastTabIndex = this.tabs.length - 1;
15516
15517 function constrain() {
15518 if ( index > lastTabIndex ) {
15519 index = 0;
15520 }
15521 if ( index < 0 ) {
15522 index = lastTabIndex;
15523 }
15524 return index;
15525 }
15526
15527 while ( $.inArray( constrain(), this.options.disabled ) !== -1 ) {
15528 index = goingForward ? index + 1 : index - 1;
15529 }
15530
15531 return index;
15532 },
15533
15534 _focusNextTab: function( index, goingForward ) {
15535 index = this._findNextTab( index, goingForward );
15536 this.tabs.eq( index ).focus();
15537 return index;
15538 },
15539
15540 _setOption: function( key, value ) {
15541 if ( key === "active" ) {
15542 // _activate() will handle invalid values and update this.options
15543 this._activate( value );
15544 return;
15545 }
15546
15547 if ( key === "disabled" ) {
15548 // don't use the widget factory's disabled handling
15549 this._setupDisabled( value );
15550 return;
15551 }
15552
15553 this._super( key, value);
15554
15555 if ( key === "collapsible" ) {
15556 this.element.toggleClass( "ui-tabs-collapsible", value );
15557 // Setting collapsible: false while collapsed; open first panel
15558 if ( !value && this.options.active === false ) {
15559 this._activate( 0 );
15560 }
15561 }
15562
15563 if ( key === "event" ) {
15564 this._setupEvents( value );
15565 }
15566
15567 if ( key === "heightStyle" ) {
15568 this._setupHeightStyle( value );
15569 }
15570 },
15571
15572 _sanitizeSelector: function( hash ) {
15573 return hash ? hash.replace( /[!"$%&'()*+,.\/:;<=>?@\[\]\^`{|}~]/g, "\\$&" ) : "";
15574 },
15575
15576 refresh: function() {
15577 var options = this.options,
15578 lis = this.tablist.children( ":has(a[href])" );
15579
15580 // get disabled tabs from class attribute from HTML
15581 // this will get converted to a boolean if needed in _refresh()
15582 options.disabled = $.map( lis.filter( ".ui-state-disabled" ), function( tab ) {
15583 return lis.index( tab );
15584 });
15585
15586 this._processTabs();
15587
15588 // was collapsed or no tabs
15589 if ( options.active === false || !this.anchors.length ) {
15590 options.active = false;
15591 this.active = $();
15592 // was active, but active tab is gone
15593 } else if ( this.active.length && !$.contains( this.tablist[ 0 ], this.active[ 0 ] ) ) {
15594 // all remaining tabs are disabled
15595 if ( this.tabs.length === options.disabled.length ) {
15596 options.active = false;
15597 this.active = $();
15598 // activate previous tab
15599 } else {
15600 this._activate( this._findNextTab( Math.max( 0, options.active - 1 ), false ) );
15601 }
15602 // was active, active tab still exists
15603 } else {
15604 // make sure active index is correct
15605 options.active = this.tabs.index( this.active );
15606 }
15607
15608 this._refresh();
15609 },
15610
15611 _refresh: function() {
15612 this._setupDisabled( this.options.disabled );
15613 this._setupEvents( this.options.event );
15614 this._setupHeightStyle( this.options.heightStyle );
15615
15616 this.tabs.not( this.active ).attr({
15617 "aria-selected": "false",
15618 "aria-expanded": "false",
15619 tabIndex: -1
15620 });
15621 this.panels.not( this._getPanelForTab( this.active ) )
15622 .hide()
15623 .attr({
15624 "aria-hidden": "true"
15625 });
15626
15627 // Make sure one tab is in the tab order
15628 if ( !this.active.length ) {
15629 this.tabs.eq( 0 ).attr( "tabIndex", 0 );
15630 } else {
15631 this.active
15632 .addClass( "ui-tabs-active ui-state-active" )
15633 .attr({
15634 "aria-selected": "true",
15635 "aria-expanded": "true",
15636 tabIndex: 0
15637 });
15638 this._getPanelForTab( this.active )
15639 .show()
15640 .attr({
15641 "aria-hidden": "false"
15642 });
15643 }
15644 },
15645
15646 _processTabs: function() {
15647 var that = this,
15648 prevTabs = this.tabs,
15649 prevAnchors = this.anchors,
15650 prevPanels = this.panels;
15651
15652 this.tablist = this._getList()
15653 .addClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
15654 .attr( "role", "tablist" )
15655
15656 // Prevent users from focusing disabled tabs via click
15657 .delegate( "> li", "mousedown" + this.eventNamespace, function( event ) {
15658 if ( $( this ).is( ".ui-state-disabled" ) ) {
15659 event.preventDefault();
15660 }
15661 })
15662
15663 // support: IE <9
15664 // Preventing the default action in mousedown doesn't prevent IE
15665 // from focusing the element, so if the anchor gets focused, blur.
15666 // We don't have to worry about focusing the previously focused
15667 // element since clicking on a non-focusable element should focus
15668 // the body anyway.
15669 .delegate( ".ui-tabs-anchor", "focus" + this.eventNamespace, function() {
15670 if ( $( this ).closest( "li" ).is( ".ui-state-disabled" ) ) {
15671 this.blur();
15672 }
15673 });
15674
15675 this.tabs = this.tablist.find( "> li:has(a[href])" )
15676 .addClass( "ui-state-default ui-corner-top" )
15677 .attr({
15678 role: "tab",
15679 tabIndex: -1
15680 });
15681
15682 this.anchors = this.tabs.map(function() {
15683 return $( "a", this )[ 0 ];
15684 })
15685 .addClass( "ui-tabs-anchor" )
15686 .attr({
15687 role: "presentation",
15688 tabIndex: -1
15689 });
15690
15691 this.panels = $();
15692
15693 this.anchors.each(function( i, anchor ) {
15694 var selector, panel, panelId,
15695 anchorId = $( anchor ).uniqueId().attr( "id" ),
15696 tab = $( anchor ).closest( "li" ),
15697 originalAriaControls = tab.attr( "aria-controls" );
15698
15699 // inline tab
15700 if ( that._isLocal( anchor ) ) {
15701 selector = anchor.hash;
15702 panelId = selector.substring( 1 );
15703 panel = that.element.find( that._sanitizeSelector( selector ) );
15704 // remote tab
15705 } else {
15706 // If the tab doesn't already have aria-controls,
15707 // generate an id by using a throw-away element
15708 panelId = tab.attr( "aria-controls" ) || $( {} ).uniqueId()[ 0 ].id;
15709 selector = "#" + panelId;
15710 panel = that.element.find( selector );
15711 if ( !panel.length ) {
15712 panel = that._createPanel( panelId );
15713 panel.insertAfter( that.panels[ i - 1 ] || that.tablist );
15714 }
15715 panel.attr( "aria-live", "polite" );
15716 }
15717
15718 if ( panel.length) {
15719 that.panels = that.panels.add( panel );
15720 }
15721 if ( originalAriaControls ) {
15722 tab.data( "ui-tabs-aria-controls", originalAriaControls );
15723 }
15724 tab.attr({
15725 "aria-controls": panelId,
15726 "aria-labelledby": anchorId
15727 });
15728 panel.attr( "aria-labelledby", anchorId );
15729 });
15730
15731 this.panels
15732 .addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
15733 .attr( "role", "tabpanel" );
15734
15735 // Avoid memory leaks (#10056)
15736 if ( prevTabs ) {
15737 this._off( prevTabs.not( this.tabs ) );
15738 this._off( prevAnchors.not( this.anchors ) );
15739 this._off( prevPanels.not( this.panels ) );
15740 }
15741 },
15742
15743 // allow overriding how to find the list for rare usage scenarios (#7715)
15744 _getList: function() {
15745 return this.tablist || this.element.find( "ol,ul" ).eq( 0 );
15746 },
15747
15748 _createPanel: function( id ) {
15749 return $( "<div>" )
15750 .attr( "id", id )
15751 .addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
15752 .data( "ui-tabs-destroy", true );
15753 },
15754
15755 _setupDisabled: function( disabled ) {
15756 if ( $.isArray( disabled ) ) {
15757 if ( !disabled.length ) {
15758 disabled = false;
15759 } else if ( disabled.length === this.anchors.length ) {
15760 disabled = true;
15761 }
15762 }
15763
15764 // disable tabs
15765 for ( var i = 0, li; ( li = this.tabs[ i ] ); i++ ) {
15766 if ( disabled === true || $.inArray( i, disabled ) !== -1 ) {
15767 $( li )
15768 .addClass( "ui-state-disabled" )
15769 .attr( "aria-disabled", "true" );
15770 } else {
15771 $( li )
15772 .removeClass( "ui-state-disabled" )
15773 .removeAttr( "aria-disabled" );
15774 }
15775 }
15776
15777 this.options.disabled = disabled;
15778 },
15779
15780 _setupEvents: function( event ) {
15781 var events = {};
15782 if ( event ) {
15783 $.each( event.split(" "), function( index, eventName ) {
15784 events[ eventName ] = "_eventHandler";
15785 });
15786 }
15787
15788 this._off( this.anchors.add( this.tabs ).add( this.panels ) );
15789 // Always prevent the default action, even when disabled
15790 this._on( true, this.anchors, {
15791 click: function( event ) {
15792 event.preventDefault();
15793 }
15794 });
15795 this._on( this.anchors, events );
15796 this._on( this.tabs, { keydown: "_tabKeydown" } );
15797 this._on( this.panels, { keydown: "_panelKeydown" } );
15798
15799 this._focusable( this.tabs );
15800 this._hoverable( this.tabs );
15801 },
15802
15803 _setupHeightStyle: function( heightStyle ) {
15804 var maxHeight,
15805 parent = this.element.parent();
15806
15807 if ( heightStyle === "fill" ) {
15808 maxHeight = parent.height();
15809 maxHeight -= this.element.outerHeight() - this.element.height();
15810
15811 this.element.siblings( ":visible" ).each(function() {
15812 var elem = $( this ),
15813 position = elem.css( "position" );
15814
15815 if ( position === "absolute" || position === "fixed" ) {
15816 return;
15817 }
15818 maxHeight -= elem.outerHeight( true );
15819 });
15820
15821 this.element.children().not( this.panels ).each(function() {
15822 maxHeight -= $( this ).outerHeight( true );
15823 });
15824
15825 this.panels.each(function() {
15826 $( this ).height( Math.max( 0, maxHeight -
15827 $( this ).innerHeight() + $( this ).height() ) );
15828 })
15829 .css( "overflow", "auto" );
15830 } else if ( heightStyle === "auto" ) {
15831 maxHeight = 0;
15832 this.panels.each(function() {
15833 maxHeight = Math.max( maxHeight, $( this ).height( "" ).height() );
15834 }).height( maxHeight );
15835 }
15836 },
15837
15838 _eventHandler: function( event ) {
15839 var options = this.options,
15840 active = this.active,
15841 anchor = $( event.currentTarget ),
15842 tab = anchor.closest( "li" ),
15843 clickedIsActive = tab[ 0 ] === active[ 0 ],
15844 collapsing = clickedIsActive && options.collapsible,
15845 toShow = collapsing ? $() : this._getPanelForTab( tab ),
15846 toHide = !active.length ? $() : this._getPanelForTab( active ),
15847 eventData = {
15848 oldTab: active,
15849 oldPanel: toHide,
15850 newTab: collapsing ? $() : tab,
15851 newPanel: toShow
15852 };
15853
15854 event.preventDefault();
15855
15856 if ( tab.hasClass( "ui-state-disabled" ) ||
15857 // tab is already loading
15858 tab.hasClass( "ui-tabs-loading" ) ||
15859 // can't switch durning an animation
15860 this.running ||
15861 // click on active header, but not collapsible
15862 ( clickedIsActive && !options.collapsible ) ||
15863 // allow canceling activation
15864 ( this._trigger( "beforeActivate", event, eventData ) === false ) ) {
15865 return;
15866 }
15867
15868 options.active = collapsing ? false : this.tabs.index( tab );
15869
15870 this.active = clickedIsActive ? $() : tab;
15871 if ( this.xhr ) {
15872 this.xhr.abort();
15873 }
15874
15875 if ( !toHide.length && !toShow.length ) {
15876 $.error( "jQuery UI Tabs: Mismatching fragment identifier." );
15877 }
15878
15879 if ( toShow.length ) {
15880 this.load( this.tabs.index( tab ), event );
15881 }
15882 this._toggle( event, eventData );
15883 },
15884
15885 // handles show/hide for selecting tabs
15886 _toggle: function( event, eventData ) {
15887 var that = this,
15888 toShow = eventData.newPanel,
15889 toHide = eventData.oldPanel;
15890
15891 this.running = true;
15892
15893 function complete() {
15894 that.running = false;
15895 that._trigger( "activate", event, eventData );
15896 }
15897
15898 function show() {
15899 eventData.newTab.closest( "li" ).addClass( "ui-tabs-active ui-state-active" );
15900
15901 if ( toShow.length && that.options.show ) {
15902 that._show( toShow, that.options.show, complete );
15903 } else {
15904 toShow.show();
15905 complete();
15906 }
15907 }
15908
15909 // start out by hiding, then showing, then completing
15910 if ( toHide.length && this.options.hide ) {
15911 this._hide( toHide, this.options.hide, function() {
15912 eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" );
15913 show();
15914 });
15915 } else {
15916 eventData.oldTab.closest( "li" ).removeClass( "ui-tabs-active ui-state-active" );
15917 toHide.hide();
15918 show();
15919 }
15920
15921 toHide.attr( "aria-hidden", "true" );
15922 eventData.oldTab.attr({
15923 "aria-selected": "false",
15924 "aria-expanded": "false"
15925 });
15926 // If we're switching tabs, remove the old tab from the tab order.
15927 // If we're opening from collapsed state, remove the previous tab from the tab order.
15928 // If we're collapsing, then keep the collapsing tab in the tab order.
15929 if ( toShow.length && toHide.length ) {
15930 eventData.oldTab.attr( "tabIndex", -1 );
15931 } else if ( toShow.length ) {
15932 this.tabs.filter(function() {
15933 return $( this ).attr( "tabIndex" ) === 0;
15934 })
15935 .attr( "tabIndex", -1 );
15936 }
15937
15938 toShow.attr( "aria-hidden", "false" );
15939 eventData.newTab.attr({
15940 "aria-selected": "true",
15941 "aria-expanded": "true",
15942 tabIndex: 0
15943 });
15944 },
15945
15946 _activate: function( index ) {
15947 var anchor,
15948 active = this._findActive( index );
15949
15950 // trying to activate the already active panel
15951 if ( active[ 0 ] === this.active[ 0 ] ) {
15952 return;
15953 }
15954
15955 // trying to collapse, simulate a click on the current active header
15956 if ( !active.length ) {
15957 active = this.active;
15958 }
15959
15960 anchor = active.find( ".ui-tabs-anchor" )[ 0 ];
15961 this._eventHandler({
15962 target: anchor,
15963 currentTarget: anchor,
15964 preventDefault: $.noop
15965 });
15966 },
15967
15968 _findActive: function( index ) {
15969 return index === false ? $() : this.tabs.eq( index );
15970 },
15971
15972 _getIndex: function( index ) {
15973 // meta-function to give users option to provide a href string instead of a numerical index.
15974 if ( typeof index === "string" ) {
15975 index = this.anchors.index( this.anchors.filter( "[href$='" + index + "']" ) );
15976 }
15977
15978 return index;
15979 },
15980
15981 _destroy: function() {
15982 if ( this.xhr ) {
15983 this.xhr.abort();
15984 }
15985
15986 this.element.removeClass( "ui-tabs ui-widget ui-widget-content ui-corner-all ui-tabs-collapsible" );
15987
15988 this.tablist
15989 .removeClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" )
15990 .removeAttr( "role" );
15991
15992 this.anchors
15993 .removeClass( "ui-tabs-anchor" )
15994 .removeAttr( "role" )
15995 .removeAttr( "tabIndex" )
15996 .removeUniqueId();
15997
15998 this.tablist.unbind( this.eventNamespace );
15999
16000 this.tabs.add( this.panels ).each(function() {
16001 if ( $.data( this, "ui-tabs-destroy" ) ) {
16002 $( this ).remove();
16003 } else {
16004 $( this )
16005 .removeClass( "ui-state-default ui-state-active ui-state-disabled " +
16006 "ui-corner-top ui-corner-bottom ui-widget-content ui-tabs-active ui-tabs-panel" )
16007 .removeAttr( "tabIndex" )
16008 .removeAttr( "aria-live" )
16009 .removeAttr( "aria-busy" )
16010 .removeAttr( "aria-selected" )
16011 .removeAttr( "aria-labelledby" )
16012 .removeAttr( "aria-hidden" )
16013 .removeAttr( "aria-expanded" )
16014 .removeAttr( "role" );
16015 }
16016 });
16017
16018 this.tabs.each(function() {
16019 var li = $( this ),
16020 prev = li.data( "ui-tabs-aria-controls" );
16021 if ( prev ) {
16022 li
16023 .attr( "aria-controls", prev )
16024 .removeData( "ui-tabs-aria-controls" );
16025 } else {
16026 li.removeAttr( "aria-controls" );
16027 }
16028 });
16029
16030 this.panels.show();
16031
16032 if ( this.options.heightStyle !== "content" ) {
16033 this.panels.css( "height", "" );
16034 }
16035 },
16036
16037 enable: function( index ) {
16038 var disabled = this.options.disabled;
16039 if ( disabled === false ) {
16040 return;
16041 }
16042
16043 if ( index === undefined ) {
16044 disabled = false;
16045 } else {
16046 index = this._getIndex( index );
16047 if ( $.isArray( disabled ) ) {
16048 disabled = $.map( disabled, function( num ) {
16049 return num !== index ? num : null;
16050 });
16051 } else {
16052 disabled = $.map( this.tabs, function( li, num ) {
16053 return num !== index ? num : null;
16054 });
16055 }
16056 }
16057 this._setupDisabled( disabled );
16058 },
16059
16060 disable: function( index ) {
16061 var disabled = this.options.disabled;
16062 if ( disabled === true ) {
16063 return;
16064 }
16065
16066 if ( index === undefined ) {
16067 disabled = true;
16068 } else {
16069 index = this._getIndex( index );
16070 if ( $.inArray( index, disabled ) !== -1 ) {
16071 return;
16072 }
16073 if ( $.isArray( disabled ) ) {
16074 disabled = $.merge( [ index ], disabled ).sort();
16075 } else {
16076 disabled = [ index ];
16077 }
16078 }
16079 this._setupDisabled( disabled );
16080 },
16081
16082 load: function( index, event ) {
16083 index = this._getIndex( index );
16084 var that = this,
16085 tab = this.tabs.eq( index ),
16086 anchor = tab.find( ".ui-tabs-anchor" ),
16087 panel = this._getPanelForTab( tab ),
16088 eventData = {
16089 tab: tab,
16090 panel: panel
16091 },
16092 complete = function( jqXHR, status ) {
16093 if ( status === "abort" ) {
16094 that.panels.stop( false, true );
16095 }
16096
16097 tab.removeClass( "ui-tabs-loading" );
16098 panel.removeAttr( "aria-busy" );
16099
16100 if ( jqXHR === that.xhr ) {
16101 delete that.xhr;
16102 }
16103 };
16104
16105 // not remote
16106 if ( this._isLocal( anchor[ 0 ] ) ) {
16107 return;
16108 }
16109
16110 this.xhr = $.ajax( this._ajaxSettings( anchor, event, eventData ) );
16111
16112 // support: jQuery <1.8
16113 // jQuery <1.8 returns false if the request is canceled in beforeSend,
16114 // but as of 1.8, $.ajax() always returns a jqXHR object.
16115 if ( this.xhr && this.xhr.statusText !== "canceled" ) {
16116 tab.addClass( "ui-tabs-loading" );
16117 panel.attr( "aria-busy", "true" );
16118
16119 this.xhr
16120 .done(function( response, status, jqXHR ) {
16121 // support: jQuery <1.8
16122 // http://bugs.jquery.com/ticket/11778
16123 setTimeout(function() {
16124 panel.html( response );
16125 that._trigger( "load", event, eventData );
16126
16127 complete( jqXHR, status );
16128 }, 1 );
16129 })
16130 .fail(function( jqXHR, status ) {
16131 // support: jQuery <1.8
16132 // http://bugs.jquery.com/ticket/11778
16133 setTimeout(function() {
16134 complete( jqXHR, status );
16135 }, 1 );
16136 });
16137 }
16138 },
16139
16140 _ajaxSettings: function( anchor, event, eventData ) {
16141 var that = this;
16142 return {
16143 url: anchor.attr( "href" ),
16144 beforeSend: function( jqXHR, settings ) {
16145 return that._trigger( "beforeLoad", event,
16146 $.extend( { jqXHR: jqXHR, ajaxSettings: settings }, eventData ) );
16147 }
16148 };
16149 },
16150
16151 _getPanelForTab: function( tab ) {
16152 var id = $( tab ).attr( "aria-controls" );
16153 return this.element.find( this._sanitizeSelector( "#" + id ) );
16154 }
16155 });
16156
16157
16158 /*!
16159 * jQuery UI Tooltip 1.11.4
16160 * http://jqueryui.com
16161 *
16162 * Copyright jQuery Foundation and other contributors
16163 * Released under the MIT license.
16164 * http://jquery.org/license
16165 *
16166 * http://api.jqueryui.com/tooltip/
16167 */
16168
16169
16170 var tooltip = $.widget( "ui.tooltip", {
16171 version: "1.11.4",
16172 options: {
16173 content: function() {
16174 // support: IE<9, Opera in jQuery <1.7
16175 // .text() can't accept undefined, so coerce to a string
16176 var title = $( this ).attr( "title" ) || "";
16177 // Escape title, since we're going from an attribute to raw HTML
16178 return $( "<a>" ).text( title ).html();
16179 },
16180 hide: true,
16181 // Disabled elements have inconsistent behavior across browsers (#8661)
16182 items: "[title]:not([disabled])",
16183 position: {
16184 my: "left top+15",
16185 at: "left bottom",
16186 collision: "flipfit flip"
16187 },
16188 show: true,
16189 tooltipClass: null,
16190 track: false,
16191
16192 // callbacks
16193 close: null,
16194 open: null
16195 },
16196
16197 _addDescribedBy: function( elem, id ) {
16198 var describedby = (elem.attr( "aria-describedby" ) || "").split( /\s+/ );
16199 describedby.push( id );
16200 elem
16201 .data( "ui-tooltip-id", id )
16202 .attr( "aria-describedby", $.trim( describedby.join( " " ) ) );
16203 },
16204
16205 _removeDescribedBy: function( elem ) {
16206 var id = elem.data( "ui-tooltip-id" ),
16207 describedby = (elem.attr( "aria-describedby" ) || "").split( /\s+/ ),
16208 index = $.inArray( id, describedby );
16209
16210 if ( index !== -1 ) {
16211 describedby.splice( index, 1 );
16212 }
16213
16214 elem.removeData( "ui-tooltip-id" );
16215 describedby = $.trim( describedby.join( " " ) );
16216 if ( describedby ) {
16217 elem.attr( "aria-describedby", describedby );
16218 } else {
16219 elem.removeAttr( "aria-describedby" );
16220 }
16221 },
16222
16223 _create: function() {
16224 this._on({
16225 mouseover: "open",
16226 focusin: "open"
16227 });
16228
16229 // IDs of generated tooltips, needed for destroy
16230 this.tooltips = {};
16231
16232 // IDs of parent tooltips where we removed the title attribute
16233 this.parents = {};
16234
16235 if ( this.options.disabled ) {
16236 this._disable();
16237 }
16238
16239 // Append the aria-live region so tooltips announce correctly
16240 this.liveRegion = $( "<div>" )
16241 .attr({
16242 role: "log",
16243 "aria-live": "assertive",
16244 "aria-relevant": "additions"
16245 })
16246 .addClass( "ui-helper-hidden-accessible" )
16247 .appendTo( this.document[ 0 ].body );
16248 },
16249
16250 _setOption: function( key, value ) {
16251 var that = this;
16252
16253 if ( key === "disabled" ) {
16254 this[ value ? "_disable" : "_enable" ]();
16255 this.options[ key ] = value;
16256 // disable element style changes
16257 return;
16258 }
16259
16260 this._super( key, value );
16261
16262 if ( key === "content" ) {
16263 $.each( this.tooltips, function( id, tooltipData ) {
16264 that._updateContent( tooltipData.element );
16265 });
16266 }
16267 },
16268
16269 _disable: function() {
16270 var that = this;
16271
16272 // close open tooltips
16273 $.each( this.tooltips, function( id, tooltipData ) {
16274 var event = $.Event( "blur" );
16275 event.target = event.currentTarget = tooltipData.element[ 0 ];
16276 that.close( event, true );
16277 });
16278
16279 // remove title attributes to prevent native tooltips
16280 this.element.find( this.options.items ).addBack().each(function() {
16281 var element = $( this );
16282 if ( element.is( "[title]" ) ) {
16283 element
16284 .data( "ui-tooltip-title", element.attr( "title" ) )
16285 .removeAttr( "title" );
16286 }
16287 });
16288 },
16289
16290 _enable: function() {
16291 // restore title attributes
16292 this.element.find( this.options.items ).addBack().each(function() {
16293 var element = $( this );
16294 if ( element.data( "ui-tooltip-title" ) ) {
16295 element.attr( "title", element.data( "ui-tooltip-title" ) );
16296 }
16297 });
16298 },
16299
16300 open: function( event ) {
16301 var that = this,
16302 target = $( event ? event.target : this.element )
16303 // we need closest here due to mouseover bubbling,
16304 // but always pointing at the same event target
16305 .closest( this.options.items );
16306
16307 // No element to show a tooltip for or the tooltip is already open
16308 if ( !target.length || target.data( "ui-tooltip-id" ) ) {
16309 return;
16310 }
16311
16312 if ( target.attr( "title" ) ) {
16313 target.data( "ui-tooltip-title", target.attr( "title" ) );
16314 }
16315
16316 target.data( "ui-tooltip-open", true );
16317
16318 // kill parent tooltips, custom or native, for hover
16319 if ( event && event.type === "mouseover" ) {
16320 target.parents().each(function() {
16321 var parent = $( this ),
16322 blurEvent;
16323 if ( parent.data( "ui-tooltip-open" ) ) {
16324 blurEvent = $.Event( "blur" );
16325 blurEvent.target = blurEvent.currentTarget = this;
16326 that.close( blurEvent, true );
16327 }
16328 if ( parent.attr( "title" ) ) {
16329 parent.uniqueId();
16330 that.parents[ this.id ] = {
16331 element: this,
16332 title: parent.attr( "title" )
16333 };
16334 parent.attr( "title", "" );
16335 }
16336 });
16337 }
16338
16339 this._registerCloseHandlers( event, target );
16340 this._updateContent( target, event );
16341 },
16342
16343 _updateContent: function( target, event ) {
16344 var content,
16345 contentOption = this.options.content,
16346 that = this,
16347 eventType = event ? event.type : null;
16348
16349 if ( typeof contentOption === "string" ) {
16350 return this._open( event, target, contentOption );
16351 }
16352
16353 content = contentOption.call( target[0], function( response ) {
16354
16355 // IE may instantly serve a cached response for ajax requests
16356 // delay this call to _open so the other call to _open runs first
16357 that._delay(function() {
16358
16359 // Ignore async response if tooltip was closed already
16360 if ( !target.data( "ui-tooltip-open" ) ) {
16361 return;
16362 }
16363
16364 // jQuery creates a special event for focusin when it doesn't
16365 // exist natively. To improve performance, the native event
16366 // object is reused and the type is changed. Therefore, we can't
16367 // rely on the type being correct after the event finished
16368 // bubbling, so we set it back to the previous value. (#8740)
16369 if ( event ) {
16370 event.type = eventType;
16371 }
16372 this._open( event, target, response );
16373 });
16374 });
16375 if ( content ) {
16376 this._open( event, target, content );
16377 }
16378 },
16379
16380 _open: function( event, target, content ) {
16381 var tooltipData, tooltip, delayedShow, a11yContent,
16382 positionOption = $.extend( {}, this.options.position );
16383
16384 if ( !content ) {
16385 return;
16386 }
16387
16388 // Content can be updated multiple times. If the tooltip already
16389 // exists, then just update the content and bail.
16390 tooltipData = this._find( target );
16391 if ( tooltipData ) {
16392 tooltipData.tooltip.find( ".ui-tooltip-content" ).html( content );
16393 return;
16394 }
16395
16396 // if we have a title, clear it to prevent the native tooltip
16397 // we have to check first to avoid defining a title if none exists
16398 // (we don't want to cause an element to start matching [title])
16399 //
16400 // We use removeAttr only for key events, to allow IE to export the correct
16401 // accessible attributes. For mouse events, set to empty string to avoid
16402 // native tooltip showing up (happens only when removing inside mouseover).
16403 if ( target.is( "[title]" ) ) {
16404 if ( event && event.type === "mouseover" ) {
16405 target.attr( "title", "" );
16406 } else {
16407 target.removeAttr( "title" );
16408 }
16409 }
16410
16411 tooltipData = this._tooltip( target );
16412 tooltip = tooltipData.tooltip;
16413 this._addDescribedBy( target, tooltip.attr( "id" ) );
16414 tooltip.find( ".ui-tooltip-content" ).html( content );
16415
16416 // Support: Voiceover on OS X, JAWS on IE <= 9
16417 // JAWS announces deletions even when aria-relevant="additions"
16418 // Voiceover will sometimes re-read the entire log region's contents from the beginning
16419 this.liveRegion.children().hide();
16420 if ( content.clone ) {
16421 a11yContent = content.clone();
16422 a11yContent.removeAttr( "id" ).find( "[id]" ).removeAttr( "id" );
16423 } else {
16424 a11yContent = content;
16425 }
16426 $( "<div>" ).html( a11yContent ).appendTo( this.liveRegion );
16427
16428 function position( event ) {
16429 positionOption.of = event;
16430 if ( tooltip.is( ":hidden" ) ) {
16431 return;
16432 }
16433 tooltip.position( positionOption );
16434 }
16435 if ( this.options.track && event && /^mouse/.test( event.type ) ) {
16436 this._on( this.document, {
16437 mousemove: position
16438 });
16439 // trigger once to override element-relative positioning
16440 position( event );
16441 } else {
16442 tooltip.position( $.extend({
16443 of: target
16444 }, this.options.position ) );
16445 }
16446
16447 tooltip.hide();
16448
16449 this._show( tooltip, this.options.show );
16450 // Handle tracking tooltips that are shown with a delay (#8644). As soon
16451 // as the tooltip is visible, position the tooltip using the most recent
16452 // event.
16453 if ( this.options.show && this.options.show.delay ) {
16454 delayedShow = this.delayedShow = setInterval(function() {
16455 if ( tooltip.is( ":visible" ) ) {
16456 position( positionOption.of );
16457 clearInterval( delayedShow );
16458 }
16459 }, $.fx.interval );
16460 }
16461
16462 this._trigger( "open", event, { tooltip: tooltip } );
16463 },
16464
16465 _registerCloseHandlers: function( event, target ) {
16466 var events = {
16467 keyup: function( event ) {
16468 if ( event.keyCode === $.ui.keyCode.ESCAPE ) {
16469 var fakeEvent = $.Event(event);
16470 fakeEvent.currentTarget = target[0];
16471 this.close( fakeEvent, true );
16472 }
16473 }
16474 };
16475
16476 // Only bind remove handler for delegated targets. Non-delegated
16477 // tooltips will handle this in destroy.
16478 if ( target[ 0 ] !== this.element[ 0 ] ) {
16479 events.remove = function() {
16480 this._removeTooltip( this._find( target ).tooltip );
16481 };
16482 }
16483
16484 if ( !event || event.type === "mouseover" ) {
16485 events.mouseleave = "close";
16486 }
16487 if ( !event || event.type === "focusin" ) {
16488 events.focusout = "close";
16489 }
16490 this._on( true, target, events );
16491 },
16492
16493 close: function( event ) {
16494 var tooltip,
16495 that = this,
16496 target = $( event ? event.currentTarget : this.element ),
16497 tooltipData = this._find( target );
16498
16499 // The tooltip may already be closed
16500 if ( !tooltipData ) {
16501
16502 // We set ui-tooltip-open immediately upon open (in open()), but only set the
16503 // additional data once there's actually content to show (in _open()). So even if the
16504 // tooltip doesn't have full data, we always remove ui-tooltip-open in case we're in
16505 // the period between open() and _open().
16506 target.removeData( "ui-tooltip-open" );
16507 return;
16508 }
16509
16510 tooltip = tooltipData.tooltip;
16511
16512 // disabling closes the tooltip, so we need to track when we're closing
16513 // to avoid an infinite loop in case the tooltip becomes disabled on close
16514 if ( tooltipData.closing ) {
16515 return;
16516 }
16517
16518 // Clear the interval for delayed tracking tooltips
16519 clearInterval( this.delayedShow );
16520
16521 // only set title if we had one before (see comment in _open())
16522 // If the title attribute has changed since open(), don't restore
16523 if ( target.data( "ui-tooltip-title" ) && !target.attr( "title" ) ) {
16524 target.attr( "title", target.data( "ui-tooltip-title" ) );
16525 }
16526
16527 this._removeDescribedBy( target );
16528
16529 tooltipData.hiding = true;
16530 tooltip.stop( true );
16531 this._hide( tooltip, this.options.hide, function() {
16532 that._removeTooltip( $( this ) );
16533 });
16534
16535 target.removeData( "ui-tooltip-open" );
16536 this._off( target, "mouseleave focusout keyup" );
16537
16538 // Remove 'remove' binding only on delegated targets
16539 if ( target[ 0 ] !== this.element[ 0 ] ) {
16540 this._off( target, "remove" );
16541 }
16542 this._off( this.document, "mousemove" );
16543
16544 if ( event && event.type === "mouseleave" ) {
16545 $.each( this.parents, function( id, parent ) {
16546 $( parent.element ).attr( "title", parent.title );
16547 delete that.parents[ id ];
16548 });
16549 }
16550
16551 tooltipData.closing = true;
16552 this._trigger( "close", event, { tooltip: tooltip } );
16553 if ( !tooltipData.hiding ) {
16554 tooltipData.closing = false;
16555 }
16556 },
16557
16558 _tooltip: function( element ) {
16559 var tooltip = $( "<div>" )
16560 .attr( "role", "tooltip" )
16561 .addClass( "ui-tooltip ui-widget ui-corner-all ui-widget-content " +
16562 ( this.options.tooltipClass || "" ) ),
16563 id = tooltip.uniqueId().attr( "id" );
16564
16565 $( "<div>" )
16566 .addClass( "ui-tooltip-content" )
16567 .appendTo( tooltip );
16568
16569 tooltip.appendTo( this.document[0].body );
16570
16571 return this.tooltips[ id ] = {
16572 element: element,
16573 tooltip: tooltip
16574 };
16575 },
16576
16577 _find: function( target ) {
16578 var id = target.data( "ui-tooltip-id" );
16579 return id ? this.tooltips[ id ] : null;
16580 },
16581
16582 _removeTooltip: function( tooltip ) {
16583 tooltip.remove();
16584 delete this.tooltips[ tooltip.attr( "id" ) ];
16585 },
16586
16587 _destroy: function() {
16588 var that = this;
16589
16590 // close open tooltips
16591 $.each( this.tooltips, function( id, tooltipData ) {
16592 // Delegate to close method to handle common cleanup
16593 var event = $.Event( "blur" ),
16594 element = tooltipData.element;
16595 event.target = event.currentTarget = element[ 0 ];
16596 that.close( event, true );
16597
16598 // Remove immediately; destroying an open tooltip doesn't use the
16599 // hide animation
16600 $( "#" + id ).remove();
16601
16602 // Restore the title
16603 if ( element.data( "ui-tooltip-title" ) ) {
16604 // If the title attribute has changed since open(), don't restore
16605 if ( !element.attr( "title" ) ) {
16606 element.attr( "title", element.data( "ui-tooltip-title" ) );
16607 }
16608 element.removeData( "ui-tooltip-title" );
16609 }
16610 });
16611 this.liveRegion.remove();
16612 }
16613 });
16614
16615
16616
16617 }));
